diff --git a/packages/core/__tests__/services/assembler-query.service.spec.ts b/packages/core/__tests__/services/assembler-query.service.spec.ts
index c5bd65fa9..db0352a68 100644
--- a/packages/core/__tests__/services/assembler-query.service.spec.ts
+++ b/packages/core/__tests__/services/assembler-query.service.spec.ts
@@ -178,7 +178,7 @@ describe('AssemblerQueryService', () => {
       const mockQueryService = mock<QueryService<TestEntity>>();
       const assemblerService = new AssemblerQueryService(new TestAssembler(), instance(mockQueryService));
       const aggQuery: AggregateQuery<TestDTO> = { count: ['foo'] };
-      const result: AggregateResponse<TestDTO> = { count: { foo: 1 } };
+      const result: AggregateResponse<TestDTO>[] = [{ count: { foo: 1 } }];
       when(
         mockQueryService.aggregateRelations(
           TestDTO,
@@ -233,10 +233,10 @@ describe('AssemblerQueryService', () => {
           objectContaining({ foo: { eq: 'bar' } }),
           aggQuery,
         ),
-      ).thenResolve(new Map<TestEntity, AggregateResponse<TestDTO>>());
+      ).thenResolve(new Map<TestEntity, AggregateResponse<TestDTO>[]>());
       return expect(
         assemblerService.aggregateRelations(TestDTO, 'test', [{ foo: 'bar' }], { foo: { eq: 'bar' } }, aggQuery),
-      ).resolves.toEqual(new Map([[dto, {}]]));
+      ).resolves.toEqual(new Map([[dto, []]]));
     });
   });
 
diff --git a/packages/core/__tests__/services/proxy-query.service.spec.ts b/packages/core/__tests__/services/proxy-query.service.spec.ts
index cfa50f48e..a6888612c 100644
--- a/packages/core/__tests__/services/proxy-query.service.spec.ts
+++ b/packages/core/__tests__/services/proxy-query.service.spec.ts
@@ -77,7 +77,7 @@ describe('ProxyQueryService', () => {
   it('should proxy to the underlying service when calling aggregate', () => {
     const filter = {};
     const aggregate: AggregateQuery<TestType> = { count: ['foo'] };
-    const result = { count: { foo: 1 } };
+    const result = [{ count: { foo: 1 } }];
     when(mockQueryService.aggregate(filter, aggregate)).thenResolve(result);
     return expect(queryService.aggregate(filter, aggregate)).resolves.toBe(result);
   });
@@ -110,7 +110,7 @@ describe('ProxyQueryService', () => {
     const dto = new TestType();
     const filter = {};
     const aggQuery: AggregateQuery<TestType> = { count: ['foo'] };
-    const result = { count: { foo: 1 } };
+    const result = [{ count: { foo: 1 } }];
     when(mockQueryService.aggregateRelations(TestType, relationName, dto, filter, aggQuery)).thenResolve(result);
     return expect(queryService.aggregateRelations(TestType, relationName, dto, filter, aggQuery)).resolves.toBe(result);
   });
@@ -120,7 +120,7 @@ describe('ProxyQueryService', () => {
     const dtos = [new TestType()];
     const filter = {};
     const aggQuery: AggregateQuery<TestType> = { count: ['foo'] };
-    const result = new Map([[{ foo: 'bar' }, { count: { foo: 1 } }]]);
+    const result = new Map([[{ foo: 'bar' }, [{ count: { foo: 1 } }]]]);
     when(mockQueryService.aggregateRelations(TestType, relationName, dtos, filter, aggQuery)).thenResolve(result);
     return expect(queryService.aggregateRelations(TestType, relationName, dtos, filter, aggQuery)).resolves.toBe(
       result,
diff --git a/packages/core/__tests__/services/relation-query.service.spec.ts b/packages/core/__tests__/services/relation-query.service.spec.ts
index b75b45a1f..c9e3137b2 100644
--- a/packages/core/__tests__/services/relation-query.service.spec.ts
+++ b/packages/core/__tests__/services/relation-query.service.spec.ts
@@ -128,7 +128,7 @@ describe('RelationQueryService', () => {
     it('should proxy to the underlying service when calling queryRelations with one dto', async () => {
       const relationName = 'test';
       const dto = new TestType();
-      const result = { count: { foo: 1 } };
+      const result = [{ count: { foo: 1 } }];
       const filter = {};
       const relationFilter = {};
       const relationAggregateQuery: AggregateQuery<TestType> = { count: ['foo'] };
@@ -143,7 +143,7 @@ describe('RelationQueryService', () => {
     it('should proxy to the underlying service when calling queryRelations with many dtos', async () => {
       const relationName = 'test';
       const dtos = [new TestType()];
-      const relationResults = { count: { foo: 1 } };
+      const relationResults = [{ count: { foo: 1 } }];
       const result = new Map([[dtos[0], relationResults]]);
       const filter = {};
       const relationFilter = {};
@@ -162,7 +162,7 @@ describe('RelationQueryService', () => {
       const dto = new TestType();
       const filter = {};
       const aggregateQuery: AggregateQuery<TestType> = { count: ['foo'] };
-      const result = { count: { foo: 1 } };
+      const result = [{ count: { foo: 1 } }];
       when(mockQueryService.aggregateRelations(TestType, relationName, dto, filter, aggregateQuery)).thenResolve(
         result,
       );
@@ -176,7 +176,7 @@ describe('RelationQueryService', () => {
       const dtos = [new TestType()];
       const filter = {};
       const aggregateQuery: AggregateQuery<TestType> = { count: ['foo'] };
-      const result = new Map([[dtos[0], { count: { foo: 1 } }]]);
+      const result = new Map([[dtos[0], [{ count: { foo: 1 } }]]]);
       when(mockQueryService.aggregateRelations(TestType, relationName, dtos, filter, aggregateQuery)).thenResolve(
         result,
       );
diff --git a/packages/core/src/interfaces/aggregate-query.interface.ts b/packages/core/src/interfaces/aggregate-query.interface.ts
index 6db2812d9..589321758 100644
--- a/packages/core/src/interfaces/aggregate-query.interface.ts
+++ b/packages/core/src/interfaces/aggregate-query.interface.ts
@@ -4,4 +4,17 @@ export type AggregateQuery<DTO> = {
   avg?: (keyof DTO)[];
   max?: (keyof DTO)[];
   min?: (keyof DTO)[];
+  groupBy?: (keyof DTO)[];
 };
+
+// const j = `invoiceAgg(filter: {}){
+//   groupBy {
+//     currency
+//     created
+//   }
+//   max {
+//     amount
+//     date
+//  };
+// }`;
+//
diff --git a/packages/core/src/interfaces/aggregate-response.interface.ts b/packages/core/src/interfaces/aggregate-response.interface.ts
index 4da63417a..c95b7b0b9 100644
--- a/packages/core/src/interfaces/aggregate-response.interface.ts
+++ b/packages/core/src/interfaces/aggregate-response.interface.ts
@@ -12,4 +12,5 @@ export type AggregateResponse<DTO> = {
   avg?: NumberAggregate<DTO>;
   max?: TypeAggregate<DTO>;
   min?: TypeAggregate<DTO>;
+  groupBy?: Partial<DTO>;
 };
diff --git a/packages/core/src/services/assembler-query.service.ts b/packages/core/src/services/assembler-query.service.ts
index ebd876eee..b096ebb92 100644
--- a/packages/core/src/services/assembler-query.service.ts
+++ b/packages/core/src/services/assembler-query.service.ts
@@ -71,12 +71,12 @@ export class AssemblerQueryService<DTO, Entity, C = DeepPartial<DTO>, CE = DeepP
     return this.assembler.convertAsyncToDTOs(this.queryService.query(this.assembler.convertQuery(query)));
   }
 
-  async aggregate(filter: Filter<DTO>, aggregate: AggregateQuery<DTO>): Promise<AggregateResponse<DTO>> {
+  async aggregate(filter: Filter<DTO>, aggregate: AggregateQuery<DTO>): Promise<AggregateResponse<DTO>[]> {
     const aggregateResponse = await this.queryService.aggregate(
       this.assembler.convertQuery({ filter }).filter || {},
       this.assembler.convertAggregateQuery(aggregate),
     );
-    return this.assembler.convertAggregateResponse(aggregateResponse);
+    return aggregateResponse.map((agg) => this.assembler.convertAggregateResponse(agg));
   }
 
   count(filter: Filter<DTO>): Promise<number> {
@@ -258,21 +258,21 @@ export class AssemblerQueryService<DTO, Entity, C = DeepPartial<DTO>, CE = DeepP
     dto: DTO,
     filter: Filter<Relation>,
     aggregate: AggregateQuery<Relation>,
-  ): Promise<AggregateResponse<Relation>>;
+  ): Promise<AggregateResponse<Relation>[]>;
   aggregateRelations<Relation>(
     RelationClass: Class<Relation>,
     relationName: string,
     dtos: DTO[],
     filter: Filter<Relation>,
     aggregate: AggregateQuery<Relation>,
-  ): Promise<Map<DTO, AggregateResponse<Relation>>>;
+  ): Promise<Map<DTO, AggregateResponse<Relation>[]>>;
   async aggregateRelations<Relation>(
     RelationClass: Class<Relation>,
     relationName: string,
     dto: DTO | DTO[],
     filter: Filter<Relation>,
     aggregate: AggregateQuery<Relation>,
-  ): Promise<AggregateResponse<Relation> | Map<DTO, AggregateResponse<Relation>>> {
+  ): Promise<AggregateResponse<Relation>[] | Map<DTO, AggregateResponse<Relation>[]>> {
     if (Array.isArray(dto)) {
       const entities = this.assembler.convertToEntities(dto);
       const relationMap = await this.queryService.aggregateRelations(
@@ -283,10 +283,10 @@ export class AssemblerQueryService<DTO, Entity, C = DeepPartial<DTO>, CE = DeepP
         aggregate,
       );
       return entities.reduce((map, e, index) => {
-        const entry = relationMap.get(e) ?? {};
+        const entry = relationMap.get(e) ?? [];
         map.set(dto[index], entry);
         return map;
-      }, new Map<DTO, AggregateResponse<Relation>>());
+      }, new Map<DTO, AggregateResponse<Relation>[]>());
     }
     return this.queryService.aggregateRelations(
       RelationClass,
diff --git a/packages/core/src/services/noop-query.service.ts b/packages/core/src/services/noop-query.service.ts
index 4a3f76d64..f697f29f5 100644
--- a/packages/core/src/services/noop-query.service.ts
+++ b/packages/core/src/services/noop-query.service.ts
@@ -88,7 +88,7 @@ export class NoOpQueryService<DTO, C = DeepPartial<DTO>, U = DeepPartial<DTO>> i
     return Promise.reject(new NotImplementedException('query is not implemented'));
   }
 
-  aggregate(filter: Filter<DTO>, aggregate: AggregateQuery<DTO>): Promise<AggregateResponse<DTO>> {
+  aggregate(filter: Filter<DTO>, aggregate: AggregateQuery<DTO>): Promise<AggregateResponse<DTO>[]> {
     return Promise.reject(new NotImplementedException('aggregate is not implemented'));
   }
 
@@ -183,7 +183,7 @@ export class NoOpQueryService<DTO, C = DeepPartial<DTO>, U = DeepPartial<DTO>> i
     dto: DTO,
     filter: Filter<Relation>,
     aggregate: AggregateQuery<Relation>,
-  ): Promise<AggregateResponse<Relation>>;
+  ): Promise<AggregateResponse<Relation>[]>;
 
   aggregateRelations<Relation>(
     RelationClass: Class<Relation>,
@@ -191,7 +191,7 @@ export class NoOpQueryService<DTO, C = DeepPartial<DTO>, U = DeepPartial<DTO>> i
     dtos: DTO[],
     filter: Filter<Relation>,
     aggregate: AggregateQuery<Relation>,
-  ): Promise<Map<DTO, AggregateResponse<Relation>>>;
+  ): Promise<Map<DTO, AggregateResponse<Relation>[]>>;
 
   aggregateRelations<Relation>(
     RelationClass: Class<Relation>,
@@ -199,7 +199,7 @@ export class NoOpQueryService<DTO, C = DeepPartial<DTO>, U = DeepPartial<DTO>> i
     dto: DTO | DTO[],
     filter: Filter<Relation>,
     aggregate: AggregateQuery<Relation>,
-  ): Promise<AggregateResponse<Relation> | Map<DTO, AggregateResponse<Relation>>> {
+  ): Promise<AggregateResponse<Relation>[] | Map<DTO, AggregateResponse<Relation>[]>> {
     return Promise.reject(new NotImplementedException('aggregateRelations is not implemented'));
   }
 }
diff --git a/packages/core/src/services/proxy-query.service.ts b/packages/core/src/services/proxy-query.service.ts
index 8d75cd536..bcfc0d61a 100644
--- a/packages/core/src/services/proxy-query.service.ts
+++ b/packages/core/src/services/proxy-query.service.ts
@@ -188,7 +188,7 @@ export class ProxyQueryService<DTO, C = DeepPartial<DTO>, U = DeepPartial<DTO>>
     return this.proxied.query(query);
   }
 
-  aggregate(filter: Filter<DTO>, query: AggregateQuery<DTO>): Promise<AggregateResponse<DTO>> {
+  aggregate(filter: Filter<DTO>, query: AggregateQuery<DTO>): Promise<AggregateResponse<DTO>[]> {
     return this.proxied.aggregate(filter, query);
   }
 
@@ -210,21 +210,21 @@ export class ProxyQueryService<DTO, C = DeepPartial<DTO>, U = DeepPartial<DTO>>
     dto: DTO,
     filter: Filter<Relation>,
     aggregate: AggregateQuery<Relation>,
-  ): Promise<AggregateResponse<Relation>>;
+  ): Promise<AggregateResponse<Relation>[]>;
   aggregateRelations<Relation>(
     RelationClass: Class<Relation>,
     relationName: string,
     dtos: DTO[],
     filter: Filter<Relation>,
     aggregate: AggregateQuery<Relation>,
-  ): Promise<Map<DTO, AggregateResponse<Relation>>>;
+  ): Promise<Map<DTO, AggregateResponse<Relation>[]>>;
   async aggregateRelations<Relation>(
     RelationClass: Class<Relation>,
     relationName: string,
     dto: DTO | DTO[],
     filter: Filter<Relation>,
     aggregate: AggregateQuery<Relation>,
-  ): Promise<AggregateResponse<Relation> | Map<DTO, AggregateResponse<Relation>>> {
+  ): Promise<AggregateResponse<Relation>[] | Map<DTO, AggregateResponse<Relation>[]>> {
     if (Array.isArray(dto)) {
       return this.proxied.aggregateRelations(RelationClass, relationName, dto, filter, aggregate);
     }
diff --git a/packages/core/src/services/query.service.ts b/packages/core/src/services/query.service.ts
index d34a4d1d8..5af6d06ba 100644
--- a/packages/core/src/services/query.service.ts
+++ b/packages/core/src/services/query.service.ts
@@ -33,7 +33,7 @@ export interface QueryService<DTO, C = DeepPartial<DTO>, U = DeepPartial<DTO>> {
    * @param filter
    * @param aggregate
    */
-  aggregate(filter: Filter<DTO>, aggregate: AggregateQuery<DTO>): Promise<AggregateResponse<DTO>>;
+  aggregate(filter: Filter<DTO>, aggregate: AggregateQuery<DTO>): Promise<AggregateResponse<DTO>[]>;
 
   /**
    * Count the number of records that match the filter.
@@ -85,7 +85,7 @@ export interface QueryService<DTO, C = DeepPartial<DTO>, U = DeepPartial<DTO>> {
     dto: DTO,
     filter: Filter<Relation>,
     aggregate: AggregateQuery<Relation>,
-  ): Promise<AggregateResponse<Relation>>;
+  ): Promise<AggregateResponse<Relation>[]>;
 
   aggregateRelations<Relation>(
     RelationClass: Class<Relation>,
@@ -93,7 +93,7 @@ export interface QueryService<DTO, C = DeepPartial<DTO>, U = DeepPartial<DTO>> {
     dtos: DTO[],
     filter: Filter<Relation>,
     aggregate: AggregateQuery<Relation>,
-  ): Promise<Map<DTO, AggregateResponse<Relation>>>;
+  ): Promise<Map<DTO, AggregateResponse<Relation>[]>>;
 
   /**
    * Count the number of relations
diff --git a/packages/core/src/services/relation-query.service.ts b/packages/core/src/services/relation-query.service.ts
index 5af5593ba..fb68f9f61 100644
--- a/packages/core/src/services/relation-query.service.ts
+++ b/packages/core/src/services/relation-query.service.ts
@@ -95,7 +95,7 @@ export class RelationQueryService<DTO, C = DeepPartial<DTO>, U = DeepPartial<DTO
     dto: DTO,
     filter: Filter<Relation>,
     aggregate: AggregateQuery<Relation>,
-  ): Promise<AggregateResponse<Relation>>;
+  ): Promise<AggregateResponse<Relation>[]>;
 
   async aggregateRelations<Relation>(
     RelationClass: Class<Relation>,
@@ -103,7 +103,7 @@ export class RelationQueryService<DTO, C = DeepPartial<DTO>, U = DeepPartial<DTO
     dtos: DTO[],
     filter: Filter<Relation>,
     aggregate: AggregateQuery<Relation>,
-  ): Promise<Map<DTO, AggregateResponse<Relation>>>;
+  ): Promise<Map<DTO, AggregateResponse<Relation>[]>>;
 
   async aggregateRelations<Relation>(
     RelationClass: Class<Relation>,
@@ -111,7 +111,7 @@ export class RelationQueryService<DTO, C = DeepPartial<DTO>, U = DeepPartial<DTO
     dto: DTO | DTO[],
     filter: Filter<Relation>,
     aggregate: AggregateQuery<Relation>,
-  ): Promise<AggregateResponse<Relation> | Map<DTO, AggregateResponse<Relation>>> {
+  ): Promise<AggregateResponse<Relation>[] | Map<DTO, AggregateResponse<Relation>[]>> {
     const serviceRelation = this.getRelation<Relation>(relationName);
     if (!serviceRelation) {
       if (Array.isArray(dto)) {
@@ -121,7 +121,7 @@ export class RelationQueryService<DTO, C = DeepPartial<DTO>, U = DeepPartial<DTO
     }
     const { query: qf, service } = serviceRelation;
     if (Array.isArray(dto)) {
-      const map = new Map<DTO, AggregateResponse<Relation>>();
+      const map = new Map<DTO, AggregateResponse<Relation>[]>();
       await Promise.all(
         dto.map(async (d) => {
           const relations = await service.aggregate(mergeQuery({ filter }, qf(d)).filter ?? {}, aggregate);