@solidxai/core 0.1.13-beta.2 → 0.1.13-beta.21

package/src/services/chatter-message.service.ts

@@ -5,8 +5,10 @@ import { InjectEntityManager } from '@nestjs/typeorm';
 import { Brackets, EntityManager, EntityMetadata, In } from 'typeorm';
 
 import { classify } from '@angular-devkit/core/src/utils/strings';
-import { CHATTER_MESSAGE_STATUS, CHATTER_MESSAGE_SUBTYPE, CHATTER_MESSAGE_TYPE } from 'src/constants/chatter-message.constants';
+import { CHATTER_MESSAGE_STATUS, CHATTER_MESSAGE_SUBTYPE, CHATTER_MESSAGE_TYPE, CHATTER_MESSAGE_USER_FIELDS } from 'src/constants/chatter-message.constants';
+import { isDangerousMediaFile } from 'src/constants/media-file-types';
 import { ERROR_MESSAGES } from 'src/constants/error-messages';
+import { MediaFieldCrudManager, SolidMediaType } from 'src/helpers/field-crud-managers/MediaFieldCrudManager';
 import { PostChatterMessageDto } from 'src/dtos/post-chatter-message.dto';
 import { UpdateChatterNoteMessageDto } from 'src/dtos/update-chatter-note-message.dto';
 import { ModelMetadataHelperService } from 'src/helpers/model-metadata-helper.service';
@@ -18,9 +20,11 @@ import { FieldMetadataRepository } from 'src/repository/field-metadata.repositor
 import { MediaRepository } from 'src/repository/media.repository';
 import { ModelMetadataRepository } from 'src/repository/model-metadata.repository';
 import { CRUDService } from 'src/services/crud.service';
+import { BasicFilterDto } from '../dtos/basic-filters.dto';
 import { MediaStorageProviderType } from '../dtos/create-media-storage-provider-metadata.dto';
 import { ChatterMessageDetails } from '../entities/chatter-message-details.entity';
 import { ChatterMessage } from '../entities/chatter-message.entity';
+import { User } from '../entities/user.entity';
 import { getMediaStorageProvider } from './mediaStorageProviders';
 import { RequestContextService } from './request-context.service';
 import { Logger } from '@nestjs/common';
@@ -34,6 +38,16 @@ interface ChatterMention {
     id?: string | number;
 }
 
+/**
+ * Server-side-only overrides for `postMessage`. Not part of `PostChatterMessageDto`, so
+ * nothing here is settable over HTTP - only in-process callers such as migration or
+ * back-fill services can supply it.
+ */
+export interface PostChatterMessageOptions {
+    /** Backdate the message instead of stamping it with the current time. */
+    createdAt?: Date;
+}
+
 @Injectable()
 export class ChatterMessageService extends CRUDService<ChatterMessage> {
     private readonly _logger = new Logger(ChatterMessageService.name);
@@ -101,6 +115,44 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
         chatterMessage.updatedBy = resolvedUserId;
     }
 
+    /**
+     * Reduce a message's hydrated `user` relation to CHATTER_MESSAGE_USER_FIELDS.
+     *
+     * `getChatterMessages` restricts the columns in the query itself, which is preferable.
+     * The generic CRUD paths below build their query from find-options and hand `populate`
+     * straight to TypeORM, so they are trimmed after the fact instead. (`createdBy` /
+     * `updatedBy` need nothing here - CRUDService.handlePopulateUserIdFields already selects
+     * only USER_SUMMARY_FIELDS when a caller populates them.)
+     */
+    private trimMessageUser<M extends ChatterMessage>(message: M): M {
+        if (message?.user) {
+            message.user = this.toUserSummary(message.user) as User;
+        }
+        return message;
+    }
+
+    private trimMessageUsers(messages: ChatterMessage[] | undefined) {
+        messages?.forEach(message => this.trimMessageUser(message));
+    }
+
+    /**
+     * `GET /chatter-message?populate[]=user` would otherwise be a way around the column
+     * allowlist applied by getChatterMessages.
+     */
+    async find(basicFilterDto: BasicFilterDto, solidRequestContext: any = {}): Promise<any> {
+        const result = await super.find(basicFilterDto, solidRequestContext);
+        this.trimMessageUsers(result?.records);
+        // A grouped find (populateGroup) nests its entities one level deeper.
+        for (const groupRecord of result?.groupRecords ?? []) {
+            this.trimMessageUsers(groupRecord?.groupData?.records);
+        }
+        return result;
+    }
+
+    async findOne(id: number, query: any = {}, solidRequestContext: any = {}) {
+        return this.trimMessageUser(await super.findOne(id, query, solidRequestContext));
+    }
+
     private isEditableCustomNoteMessage(message: ChatterMessage): boolean {
         if (message.messageType !== CHATTER_MESSAGE_TYPE.CUSTOM) {
             return false;
@@ -134,6 +186,45 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
         }, messageBody || '');
     }
 
+    /**
+     * Chatter attachments bypass MediaFieldCrudManager - they go straight to
+     * storageProvider.store() - so the shared predicate is applied here directly. The rules
+     * themselves live in media-file-types so upload paths can't drift apart.
+     */
+    private validateChatterMediaFiles(files: Express.Multer.File[] = []) {
+        if (Array.isArray(files) && files.some(file => isDangerousMediaFile(file))) {
+            throw new BadRequestException('Dangerous file types are not allowed in chatter attachments.');
+        }
+    }
+
+    /**
+     * Validates newly-uploaded attachments against each declared media field's real config
+     * (mediaTypes/mediaMaxSizeKb/mediaAllowedExtensions), grouped by fieldname - the same rules
+     * MediaFieldCrudManager already enforces everywhere else. Shared between postMessage and
+     * updateCustomNoteMessage so the two entry points can't drift apart; isUpdate is the only
+     * thing that differs between them.
+     */
+    private validateChatterAttachmentsForFields(files: Express.Multer.File[], mediaFields: any[], isUpdate: boolean): void {
+        for (const mediaField of mediaFields) {
+            const media = files.filter(multerFile => multerFile.fieldname === mediaField.name);
+            if (media.length === 0) continue;
+
+            const validator = new MediaFieldCrudManager({
+                type: mediaField.type as SolidMediaType,
+                required: mediaField.required,
+                fieldName: mediaField.name,
+                mediaMaxSizeKb: mediaField.mediaMaxSizeKb,
+                mediaTypes: mediaField.mediaTypes,
+                mediaAllowedExtensions: mediaField.mediaAllowedExtensions,
+                isUpdate,
+            });
+            const validationErrors = validator.validate({}, media);
+            if (validationErrors.length > 0) {
+                throw new BadRequestException(validationErrors.map(error => error.error).join(', '));
+            }
+        }
+    }
+
     private async publishChatterMentionNotifications(message: ChatterMessage, model: any) {
         if (message.messageType !== CHATTER_MESSAGE_TYPE.CUSTOM || message.messageSubType !== CHATTER_MESSAGE_SUBTYPE.NOTE) {
             return;
@@ -188,6 +279,31 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
         }
     }
 
+    // Deliberately bypasses UserRepository's security-rule filtering: the mention picker
+    // needs id/username/fullName for any active user regardless of the caller's row-level
+    // access to the User model, same as the getChatterMessages one-to-many lookup below.
+    async getMentionableUsers(search?: string, limit: number = 8): Promise<Array<{ id: number; username: string; fullName: string }>> {
+        const normalizedLimit = Number.isInteger(limit) && limit > 0 && limit <= 50 ? limit : 8;
+        const userRepository = this.entityManager.getRepository(User);
+
+        const qb = userRepository
+            .createQueryBuilder('user')
+            .select(['user.id', 'user.username', 'user.fullName'])
+            .where('user.active = :active', { active: true });
+
+        const trimmedSearch = (search ?? '').trim();
+        if (trimmedSearch) {
+            qb.andWhere('(LOWER(user.username) LIKE :search OR LOWER(user.fullName) LIKE :search)', {
+                search: `%${trimmedSearch.toLowerCase()}%`,
+            });
+        }
+
+        qb.orderBy('user.username', 'ASC').take(normalizedLimit);
+
+        const users = await qb.getMany();
+        return users.map(user => ({ id: user.id, username: user.username, fullName: user.fullName }));
+    }
+
     async markCompleted(id: number) {
         const activeUser = this.requestContextService.getActiveUser();
         if (!activeUser) {
@@ -240,6 +356,26 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
             throw new BadRequestException('Message body cannot be empty.');
         }
 
+        this.validateChatterMediaFiles(files);
+
+        let chatterModel: any = null;
+        let mediaFields: any[] = [];
+        if (removeAttachmentIds.length > 0 || hasNewFiles) {
+            chatterModel = await this.modelMetadataService.findOneBySingularName('chatterMessage', {
+                fields: {
+                    model: true,
+                    mediaStorageProvider: true,
+                },
+                module: true,
+            });
+
+            mediaFields = chatterModel.fields.filter(field => field.type === 'mediaSingle' || field.type === 'mediaMultiple');
+
+            if (hasNewFiles) {
+                this.validateChatterAttachmentsForFields(files, mediaFields, true);
+            }
+        }
+
         if (hasMessageBody) {
             message.messageBody = trimmedMessageBody;
         }
@@ -256,15 +392,6 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
         const savedMessage = await this.repo.save(message);
 
         if (removeAttachmentIds.length > 0 || hasNewFiles) {
-            const model = await this.modelMetadataService.findOneBySingularName('chatterMessage', {
-                fields: {
-                    model: true,
-                    mediaStorageProvider: true,
-                },
-                module: true,
-            });
-
-            const mediaFields = model.fields.filter(field => field.type === 'mediaSingle' || field.type === 'mediaMultiple');
             const attachmentFieldIds = mediaFields.map(field => field.id);
 
             if (removeAttachmentIds.length > 0 && attachmentFieldIds.length > 0) {
@@ -272,7 +399,7 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
                     where: {
                         id: In(removeAttachmentIds),
                         entityId: savedMessage.id,
-                        modelMetadata: { id: model.id },
+                        modelMetadata: { id: chatterModel.id },
                         fieldMetadata: { id: In(attachmentFieldIds) },
                     },
                     relations: {
@@ -306,13 +433,23 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
 
         await this.publishChatterMentionNotifications(savedMessage, model);
 
-        return savedMessage;
+        // The `user` relation was loaded for the ownership check above; don't return all of it.
+        return this.trimMessageUser(savedMessage);
     }
 
-    async postMessage(postDto: PostChatterMessageDto, files: Express.Multer.File[] = []) {
+    /**
+     * Post a chatter message.
+     *
+     * `options` is deliberately kept out of `PostChatterMessageDto` so it can only be supplied
+     * by server-side callers (migrations, back-fills). The controller binds the DTO alone, so
+     * an API client has no way to backdate a message.
+     */
+    async postMessage(postDto: PostChatterMessageDto, files: Express.Multer.File[] = [], options: PostChatterMessageOptions = {}) {
         const coModelName = lowerFirst(postDto.coModelName);
         await this.assertRecordAccess(coModelName, postDto.coModelEntityId);
 
+        this.validateChatterMediaFiles(files);
+
         const chatterMessage = new ChatterMessage();
         chatterMessage.messageType = CHATTER_MESSAGE_TYPE.CUSTOM;
         chatterMessage.messageSubType = postDto.messageSubType || CHATTER_MESSAGE_SUBTYPE.CUSTOM;
@@ -322,6 +459,10 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
         chatterMessage.coModelEntityId = postDto.coModelEntityId;
         chatterMessage.coModelName = coModelName;
         chatterMessage.modelUserKey = postDto.modelUserKey ?? null;
+        // Left unset otherwise, so the @CreateDateColumn default still applies.
+        if (options.createdAt) {
+            chatterMessage.createdAt = options.createdAt;
+        }
 
         const model = await this.modelMetadataRepo.findOne({
             where: { singularName: coModelName },
@@ -331,10 +472,9 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
 
         this.stampMessageAuditFields(chatterMessage);
 
-        const savedMessage = await this.repo.save(chatterMessage);
-
+        let mediaFields: any[] = [];
         if (files && files.length > 0) {
-            const model = await this.modelMetadataService.findOneBySingularName('chatterMessage', {
+            const chatterModel = await this.modelMetadataService.findOneBySingularName('chatterMessage', {
                 fields: {
                     model: true,
                     mediaStorageProvider: true,
@@ -342,8 +482,13 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
                 module: true,
             });
 
-            const mediaFields = model.fields.filter(field => field.type === 'mediaSingle' || field.type === 'mediaMultiple');
+            mediaFields = chatterModel.fields.filter(field => field.type === 'mediaSingle' || field.type === 'mediaMultiple');
+            this.validateChatterAttachmentsForFields(files, mediaFields, false);
+        }
+
+        const savedMessage = await this.repo.save(chatterMessage);
 
+        if (files && files.length > 0) {
             for (const mediaField of mediaFields) {
                 const media = files.filter(multerFile => multerFile.fieldname === mediaField.name);
                 if (media.length > 0) {
@@ -891,16 +1036,25 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
             qb.where(orConditions.join(' OR '), parameters);
         }));
 
-        const relations = ['chatterMessageDetails', 'user'];
+        const relations = ['chatterMessageDetails'];
         if (populate && populate.length > 0) {
             const normalizedPopulate = this.crudHelperService.normalize(populate);
-            relations.push(...normalizedPopulate.filter(rel => !relations.includes(rel)));
+            // SECURITY: 'user' is joined below with an explicit column allowlist. A client-supplied
+            // populate[]=user must not be able to turn it back into a full-entity join (the chatter
+            // panel does send exactly that).
+            relations.push(...normalizedPopulate.filter(rel => rel !== 'user' && !relations.includes(rel)));
         }
 
         relations.forEach(relation => {
             qb.leftJoinAndSelect(`entity.${relation}`, relation);
         });
 
+        // Only the author's id and display name leave this endpoint - see CHATTER_MESSAGE_USER_FIELDS.
+        // This join must stay before applyFilters below: it lets filters[user][fullName] reuse this
+        // alias instead of adding a second join of its own.
+        qb.leftJoin('entity.user', 'user');
+        qb.addSelect(CHATTER_MESSAGE_USER_FIELDS.map(field => `user.${field}`));
+
         if (filters) {
             qb.andWhere(new Brackets(whereQb => {
                 this.crudHelperService.applyFilters(whereQb, filters, 'entity', qb);
@@ -914,6 +1068,13 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
         const [entities, count] = await qb.getManyAndCount();
         this.logHeapUsed('getChatterMessages-entitiesLoaded');
 
+        // The join above only selects the allowlisted columns, but TypeORM still hydrates the
+        // author with `new User()`, which leaves every initialiser-backed property (active,
+        // forcePasswordChange, ...) sitting on the instance holding its default rather than a
+        // value read from the database. Replace it with a plain object of exactly the
+        // allowlisted keys so the response cannot report fabricated defaults as data.
+        this.trimMessageUsers(entities);
+
         // Convert date strings in message details to ISO format for consistent handling on the frontend
         const DATE_FIELD_TYPES = ['date', 'datetime', 'time'];
         for (const entity of entities) {

package/src/services/crud-helper.service.ts

@@ -3,9 +3,12 @@ import { BasicFilterDto } from "../dtos/basic-filters.dto";
 import { classify } from '../helpers/string.helper';
 import { ActiveUserData } from "src/interfaces/active-user-data.interface";
 import { SolidRegistry } from "src/helpers/solid-registry";
-import { BadRequestException, Logger } from "@nestjs/common";
+import { BadRequestException, Injectable, Logger } from "@nestjs/common";
 import { ERROR_MESSAGES } from "src/constants/error-messages";
 import { buildCastToText } from "src/helpers/typeorm-db-helper";
+import { DraftPublishHelperService } from "./draft-publish-helper.service";
+import { InternationalisationHelperService } from "./internationalisation-helper.service";
+import { normalizeObjectKeys } from "./object.utils";
 
 export enum FilterCombinator {
     AND = '$and',
@@ -36,10 +39,14 @@ export interface ResolvedFieldPath {
     leafIsRelation: boolean;
 }
 
+@Injectable()
 export class CrudHelperService {
+    private readonly logger = new Logger(CrudHelperService.name);
+
     constructor(
+        private readonly draftPublishHelperService: DraftPublishHelperService,
+        private readonly internationalisationHelperService: InternationalisationHelperService,
     ) { }
-    private readonly logger = new Logger(CrudHelperService.name);
 
     /**
      * Resolve a user-supplied dotted path (e.g. "customer.name") against real TypeORM metadata.
@@ -163,7 +170,7 @@ export class CrudHelperService {
     }
 
     applyFilters(qb: WhereExpressionBuilder, filters: any, alias: string = 'entity', selectQb: SelectQueryBuilder<any>) {
-        const normalizedFilters = this.normalizeObjectKeys(filters);
+        const normalizedFilters = normalizeObjectKeys(filters);
         if (normalizedFilters.$and) {
             normalizedFilters.$and.forEach((andFilter: any) => {
                 qb.andWhere(
@@ -182,7 +189,7 @@ export class CrudHelperService {
             // For individual conditions
             Object.keys(normalizedFilters).forEach(key => {
                 const primaryFilterObj = normalizedFilters[key];
-                const normalizedPrimaryFilterObj = this.normalizeObjectKeys(primaryFilterObj);
+                const normalizedPrimaryFilterObj = normalizeObjectKeys(primaryFilterObj);
 
                 const [rawField, funcAlias] = key.split(':');
 
@@ -312,17 +319,6 @@ export class CrudHelperService {
         }
     }
 
-    // Normalize the primary operator object by removing the surrounding brackets in the keys e.g [$eq] => $eq
-    private normalizeObjectKeys(obj: any): any {
-        return Object.keys(obj).reduce((acc, key) => {
-            // Transform the key by removing surrounding brackets
-            const newKey = key.replace(/^\[(.*)\]$/, '$1');
-            // Assign the value to the transformed key in the accumulator object
-            acc[newKey] = obj[key];
-            return acc;
-        }, {});
-    }
-
     normalize(value: string | string[]): string[] {
         if (!value) return []; // if the value is nullish, then return an empty array
         return Array.isArray(value) ? value : [value];        // if the value is an array, return it as is, otherwise return it as an array
@@ -359,7 +355,7 @@ export class CrudHelperService {
         applySorting: boolean = true
     ): SelectQueryBuilder<any> { // TODO : Check how to pass a type to SelectQueryBuilder instead of any
         let { limit, offset, showSoftDeleted, filters } = basicFilterDto;
-        const { fields, sort, populate = [], populateMedia = [], locale, status } = basicFilterDto;
+        const { fields, sort, populate = [], populateMedia = [], locale } = basicFilterDto;
 
         // Normalize the fields, sort, groupBy and populate options i.e (since they can be either a string or an array of strings, when coming from the request)
         const normalizedFields = this.normalize(fields);
@@ -390,28 +386,14 @@ export class CrudHelperService {
             }
         }
 
-        let finalLocale = locale
         if (internationalisation) {
-            // If locale is not provided in the filter dto, then assume it is the default locale to be used. 
-            if (!finalLocale) {
-                //Get default locale from registry
-                const solidRegistry = moduleRef.get(SolidRegistry, { strict: false });
-                const defaultLocale = solidRegistry.getDefaultLocale();
-                if(defaultLocale){
-                    finalLocale = defaultLocale.locale;
-                }else{
-                    finalLocale = 'en';
-                }
-            }
+            // If locale is not provided in the filter dto, then assume it is the default locale to be used.
+            const finalLocale = locale || this.internationalisationHelperService.resolveDefaultLocaleName(moduleRef.get(SolidRegistry, { strict: false }));
             qb.andWhere(`${entityAlias}.localeName = :locale`, { locale: finalLocale });
         }
 
-        if (draftPublishWorkflow && status) {
-            if (basicFilterDto.status === 'published') {
-                qb.andWhere(`${entityAlias}.publishedAt IS NOT NULL`);
-            } else if (basicFilterDto.status === 'draft') {
-                qb.andWhere(`${entityAlias}.publishedAt IS NULL`);
-            }
+        if (draftPublishWorkflow) {
+            this.draftPublishHelperService.applyDraftPublishFilterDefaults(qb, filters, entityAlias);
         }
         // Depending upon the select option, apply the select clause
         if (normalizedFields && normalizedFields.length) {
@@ -907,25 +889,25 @@ export class CrudHelperService {
         };
     }
 
-    async countGroupedRecords(qb: SelectQueryBuilder<any>, basicFilterDto: BasicFilterDto, entityAlias: string) { //TODO : Check how to pass a type to SelectQueryBuilder instead of any
-        const { limit, offset, ...rest } = basicFilterDto;
-        const filteredDto = { ...rest, limit: undefined, offset: undefined };
+    // async countGroupedRecords(qb: SelectQueryBuilder<any>, basicFilterDto: BasicFilterDto, entityAlias: string, internationalisation?: boolean, draftPublishWorkflow?: boolean, moduleRef?: any) { //TODO : Check how to pass a type to SelectQueryBuilder instead of any
+    //     const { limit, offset, ...rest } = basicFilterDto;
+    //     const filteredDto = { ...rest, limit: undefined, offset: undefined };
 
-        const filteredQB = this.buildFilterQuery(qb, filteredDto as BasicFilterDto, entityAlias, undefined, undefined, undefined, FilterCombinator.AND, false, false);
+    //     const filteredQB = this.buildFilterQuery(qb, filteredDto as BasicFilterDto, entityAlias, internationalisation, draftPublishWorkflow, moduleRef, FilterCombinator.AND, false, false);
 
-        const groupByFields = this.normalize(filteredDto.groupBy);
+    //     const groupByFields = this.normalize(filteredDto.groupBy);
 
-        if (!groupByFields || groupByFields.length === 0) {
-            throw new Error(ERROR_MESSAGES.INVALID_GROUP_BY_COUNT);
-        }
+    //     if (!groupByFields || groupByFields.length === 0) {
+    //         throw new Error(ERROR_MESSAGES.INVALID_GROUP_BY_COUNT);
+    //     }
 
-        this.applyGroupBySelections(filteredQB, groupByFields, entityAlias);
-        this.applyAggregates(filteredQB, ['count'], entityAlias);
-        filteredQB.limit(undefined).offset(undefined).take(undefined).skip(undefined);
+    //     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;
-    }
+    //     const rawResults = await filteredQB.getRawMany();
+    //     return rawResults.length;
+    // }
 
     hasReadPermissionOnModel = (activeUser: ActiveUserData, modelName: string) => {
         const permissionNames = [`${classify(modelName)}Controller.findOne`, `${classify(modelName)}Controller.findMany`];
@@ -998,7 +980,10 @@ export class CrudHelperService {
         basicFilterDto: BasicFilterDto,
         alias: string,
         createQbFn: () => Promise<SelectQueryBuilder<T>>,
-        postProcessEntities?: (entities: T[]) => Promise<void>
+        postProcessEntities?: (entities: T[]) => Promise<void>,
+        internationalisation?: boolean,
+        draftPublishWorkflow?: boolean,
+        moduleRef?: any
     ): Promise<{ meta: { totalRecords: number }; groupMeta: any[]; groupRecords: any[] }> {
         const groupByFields = this.normalize(basicFilterDto.groupBy);
         if (!groupByFields.length) throw new BadRequestException(ERROR_MESSAGES.INVALID_GROUP_BY_COUNT);
@@ -1033,7 +1018,7 @@ export class CrudHelperService {
                     aggregates: undefined,
                     sort: basicFilterDto.groupFilter?.sort,
                 };
-                groupQb = this.buildFilterQuery(groupQb, groupFilterDto, alias);
+                groupQb = this.buildFilterQuery(groupQb, groupFilterDto, alias, internationalisation, draftPublishWorkflow, moduleRef);
                 groupQb = this.buildGroupByRecordsQuery(groupQb, group, alias, groupAliasMap, aggregateAliasMap, groupExpressionMap);
                 const [entities, count] = await groupQb.getManyAndCount();
                 if (postProcessEntities) await postProcessEntities(entities);