@drax/crud-back 3.17.0 → 3.17.3

package/dist/repository/AbstractMongoRepository.js

@@ -9,6 +9,9 @@ class AbstractMongoRepository {
         this._populateFields = [];
         this._lean = true;
     }
+    getNestedValue(source, path) {
+        return path.split('.').reduce((value, key) => value == null ? undefined : value[key], source);
+    }
     assertId(id) {
         if (!mongoose.Types.ObjectId.isValid(id)) {
             console.log(`Invalid ID: ${id} is not a valid ObjectId.`);
@@ -228,17 +231,29 @@ class AbstractMongoRepository {
         const schema = this._model.schema;
         // Construir el objeto de agrupación dinámicamente
         const groupId = {};
-        const lookupStages = [];
+        const preGroupStages = [];
+        const postGroupStages = [];
         const finalProjectFields = { count: 1, _id: 0 };
         const refFields = new Set();
         const dateFields = new Set();
         const numericFields = new Set();
         const groupFields = [];
+        const groupFieldAliases = new Map();
+        const preGroupLookupAliases = new Map();
         const numericInstances = new Set(['Number', 'Decimal128', 'Double', 'Int32', 'Long', 'BigInt']);
         const totalGroupFields = fields.filter(field => {
             const schemaPath = schema.path(field);
             return !(schemaPath && numericInstances.has(schemaPath.instance));
         }).length;
+        const getGroupFieldAlias = (field) => {
+            const existingAlias = groupFieldAliases.get(field);
+            if (existingAlias) {
+                return existingAlias;
+            }
+            const newAlias = `field_${groupFieldAliases.size}`;
+            groupFieldAliases.set(field, newAlias);
+            return newAlias;
+        };
         // Función para obtener el formato de fecha según el nivel de granularidad
         const getDateFormat = (field, format) => {
             const formats = {
@@ -293,8 +308,38 @@ class AbstractMongoRepository {
             };
             return formats[format] || formats['day'];
         };
+        const ensureLookupForReferencedField = (field, refModel) => {
+            const existingAlias = preGroupLookupAliases.get(field);
+            if (existingAlias) {
+                return existingAlias;
+            }
+            const refModelInstance = mongoose.model(refModel);
+            const collectionName = refModelInstance.collection.name;
+            const lookupAlias = `${field}_groupByRef`;
+            preGroupStages.push({
+                $lookup: {
+                    from: collectionName,
+                    localField: field,
+                    foreignField: '_id',
+                    as: lookupAlias
+                }
+            });
+            preGroupStages.push({
+                $unwind: {
+                    path: `$${lookupAlias}`,
+                    preserveNullAndEmptyArrays: true
+                }
+            });
+            preGroupLookupAliases.set(field, lookupAlias);
+            return lookupAlias;
+        };
         fields.forEach(field => {
             const schemaPath = schema.path(field);
+            const fieldAlias = getGroupFieldAlias(field);
+            const fieldParts = field.split('.');
+            const rootField = fieldParts[0];
+            const nestedFieldPath = fieldParts.slice(1).join('.');
+            const rootSchemaPath = rootField === field ? schemaPath : schema.path(rootField);
             // Verificar si el campo es numérico: se agregará con $sum y no formará parte de la clave de agrupación
             if (schemaPath && numericInstances.has(schemaPath.instance)) {
                 numericFields.add(field);
@@ -305,50 +350,54 @@ class AbstractMongoRepository {
             // Verificar si el campo es de tipo Date
             if (schemaPath && schemaPath.instance === 'Date') {
                 dateFields.add(field);
-                groupId[field] = getDateFormat(field, dateFormat);
+                groupId[fieldAlias] = getDateFormat(field, dateFormat);
             }
             // Verificar si el campo es una referencia
             else if (schemaPath && schemaPath.options && schemaPath.options.ref) {
                 const refModel = schemaPath.options.ref;
-                const fieldName = field;
                 refFields.add(field);
                 // Obtener el modelo referenciado y su nombre de colección real
                 const refModelInstance = mongoose.model(refModel);
                 const collectionName = refModelInstance.collection.name;
                 // Determinar el campo local correcto según si es un solo campo o múltiples
-                const localField = totalGroupFields === 1 ? '_id' : `_id.${fieldName}`;
-                lookupStages.push({
+                const localField = totalGroupFields === 1 ? '_id' : `_id.${fieldAlias}`;
+                postGroupStages.push({
                     $lookup: {
                         from: collectionName,
                         localField: localField,
                         foreignField: '_id',
-                        as: `${fieldName}_populated`
+                        as: `${fieldAlias}_populated`
                     }
                 });
                 // Unwind para convertir el array en objeto único
-                lookupStages.push({
+                postGroupStages.push({
                     $unwind: {
-                        path: `$${fieldName}_populated`,
+                        path: `$${fieldAlias}_populated`,
                         preserveNullAndEmptyArrays: true
                     }
                 });
                 // En la proyección final, usar el objeto poblado
-                finalProjectFields[field] = `$${fieldName}_populated`;
-                groupId[field] = `$${field}`;
+                finalProjectFields[field] = `$${fieldAlias}_populated`;
+                groupId[fieldAlias] = `$${field}`;
+            }
+            else if (nestedFieldPath && rootSchemaPath && rootSchemaPath.options && rootSchemaPath.options.ref) {
+                const lookupAlias = ensureLookupForReferencedField(rootField, rootSchemaPath.options.ref);
+                groupId[fieldAlias] = `$${lookupAlias}.${nestedFieldPath}`;
             }
             else {
                 // Si no es una referencia ni fecha, usar el valor directo
-                groupId[field] = `$${field}`;
+                groupId[fieldAlias] = `$${field}`;
             }
         });
         // Construir la proyección final para campos de fecha
         groupFields.forEach(field => {
+            const fieldAlias = groupFieldAliases.get(field);
             if (dateFields.has(field)) {
                 if (groupFields.length === 1) {
                     finalProjectFields[field] = `$_id`;
                 }
                 else {
-                    finalProjectFields[field] = `$_id.${field}`;
+                    finalProjectFields[field] = `$_id.${fieldAlias}`;
                 }
             }
             else if (!refFields.has(field)) {
@@ -356,7 +405,7 @@ class AbstractMongoRepository {
                     finalProjectFields[field] = `$_id`;
                 }
                 else {
-                    finalProjectFields[field] = `$_id.${field}`;
+                    finalProjectFields[field] = `$_id.${fieldAlias}`;
                 }
             }
         });
@@ -369,27 +418,41 @@ class AbstractMongoRepository {
         });
         if (groupFields.length === 1) {
             const field = groupFields[0];
-            groupStage._id = dateFields.has(field) ? getDateFormat(field, dateFormat) : groupId[field];
+            const fieldAlias = groupFieldAliases.get(field);
+            groupStage._id = dateFields.has(field) ? getDateFormat(field, dateFormat) : groupId[fieldAlias];
         }
         else if (groupFields.length > 1) {
             groupStage._id = groupId;
         }
         const pipeline = [
             { $match: query },
+            ...preGroupStages,
             {
                 $group: groupStage
             }
         ];
         // Solo agregar lookups si hay campos de referencia
-        if (lookupStages.length > 0) {
-            pipeline.push(...lookupStages);
+        if (postGroupStages.length > 0) {
+            pipeline.push(...postGroupStages);
         }
         pipeline.push({
             $project: finalProjectFields
         }, { $sort: { count: -1 } });
         // console.log("pipeline", JSON.stringify(pipeline, null, 2))
         const result = await this._model.aggregate(pipeline).exec();
-        return result;
+        return result.map((item) => {
+            const normalizedItem = { ...item };
+            groupFields.forEach(field => {
+                if (!field.includes('.') || normalizedItem[field] !== undefined) {
+                    return;
+                }
+                const nestedValue = this.getNestedValue(normalizedItem, field);
+                if (nestedValue !== undefined) {
+                    normalizedItem[field] = nestedValue;
+                }
+            });
+            return normalizedItem;
+        });
     }
 }
 export default AbstractMongoRepository;

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "3.17.0",
+  "version": "3.17.3",
   "description": "Crud utils across modules",
   "main": "dist/index.js",
   "types": "types/index.d.ts",
@@ -25,7 +25,7 @@
     "@drax/common-back": "^3.14.0",
     "@drax/common-share": "^3.0.0",
     "@drax/identity-share": "^3.15.0",
-    "@drax/media-back": "^3.17.0",
+    "@drax/media-back": "^3.17.3",
     "@graphql-tools/load-files": "^7.0.0",
     "@graphql-tools/merge": "^9.0.4",
     "mongoose": "^8.23.0",
@@ -47,5 +47,5 @@
     "typescript": "^5.9.3",
     "vitest": "^3.2.4"
   },
-  "gitHead": "d8a056b087d67157bc8c2e684b7e6696399d06a4"
+  "gitHead": "f3cc4a70c5f96cb4a5de6da037f7dd0d3eed6202"
 }

package/src/repository/AbstractMongoRepository.ts

@@ -30,6 +30,10 @@ class AbstractMongoRepository<T, C, U> implements IDraxCrud<T, C, U> {
     protected _populateFields: string[] | PopulateOptions[] = []
     protected _lean: boolean = true
 
+    private getNestedValue(source: any, path: string): any {
+        return path.split('.').reduce((value, key) => value == null ? undefined : value[key], source)
+    }
+
     assertId(id: string): void {
         if (!mongoose.Types.ObjectId.isValid(id)) {
             console.log(`Invalid ID: ${id} is not a valid ObjectId.`)
@@ -337,18 +341,32 @@ class AbstractMongoRepository<T, C, U> implements IDraxCrud<T, C, U> {
 
         // Construir el objeto de agrupación dinámicamente
         const groupId: any = {}
-        const lookupStages: any[] = []
+        const preGroupStages: any[] = []
+        const postGroupStages: any[] = []
         const finalProjectFields: any = {count: 1, _id: 0}
         const refFields = new Set<string>()
         const dateFields = new Set<string>()
         const numericFields = new Set<string>()
         const groupFields: string[] = []
+        const groupFieldAliases = new Map<string, string>()
+        const preGroupLookupAliases = new Map<string, string>()
         const numericInstances = new Set(['Number', 'Decimal128', 'Double', 'Int32', 'Long', 'BigInt'])
         const totalGroupFields = fields.filter(field => {
             const schemaPath = schema.path(field)
             return !(schemaPath && numericInstances.has(schemaPath.instance))
         }).length
 
+        const getGroupFieldAlias = (field: string): string => {
+            const existingAlias = groupFieldAliases.get(field)
+            if (existingAlias) {
+                return existingAlias
+            }
+
+            const newAlias = `field_${groupFieldAliases.size}`
+            groupFieldAliases.set(field, newAlias)
+            return newAlias
+        }
+
         // Función para obtener el formato de fecha según el nivel de granularidad
         const getDateFormat = (field: string, format: string) => {
             const formats = {
@@ -404,8 +422,43 @@ class AbstractMongoRepository<T, C, U> implements IDraxCrud<T, C, U> {
             return formats[format] || formats['day']
         }
 
+        const ensureLookupForReferencedField = (field: string, refModel: string): string => {
+            const existingAlias = preGroupLookupAliases.get(field)
+            if (existingAlias) {
+                return existingAlias
+            }
+
+            const refModelInstance = mongoose.model(refModel)
+            const collectionName = refModelInstance.collection.name
+            const lookupAlias = `${field}_groupByRef`
+
+            preGroupStages.push({
+                $lookup: {
+                    from: collectionName,
+                    localField: field,
+                    foreignField: '_id',
+                    as: lookupAlias
+                }
+            })
+
+            preGroupStages.push({
+                $unwind: {
+                    path: `$${lookupAlias}`,
+                    preserveNullAndEmptyArrays: true
+                }
+            })
+
+            preGroupLookupAliases.set(field, lookupAlias)
+            return lookupAlias
+        }
+
         fields.forEach(field => {
             const schemaPath = schema.path(field)
+            const fieldAlias = getGroupFieldAlias(field)
+            const fieldParts = field.split('.')
+            const rootField = fieldParts[0]
+            const nestedFieldPath = fieldParts.slice(1).join('.')
+            const rootSchemaPath = rootField === field ? schemaPath : schema.path(rootField)
 
             // Verificar si el campo es numérico: se agregará con $sum y no formará parte de la clave de agrupación
             if (schemaPath && numericInstances.has(schemaPath.instance)) {
@@ -419,12 +472,11 @@ class AbstractMongoRepository<T, C, U> implements IDraxCrud<T, C, U> {
             // Verificar si el campo es de tipo Date
             if (schemaPath && schemaPath.instance === 'Date') {
                 dateFields.add(field)
-                groupId[field] = getDateFormat(field, dateFormat)
+                groupId[fieldAlias] = getDateFormat(field, dateFormat)
             }
             // Verificar si el campo es una referencia
             else if (schemaPath && schemaPath.options && schemaPath.options.ref) {
                 const refModel = schemaPath.options.ref
-                const fieldName = field
 
                 refFields.add(field)
 
@@ -433,47 +485,51 @@ class AbstractMongoRepository<T, C, U> implements IDraxCrud<T, C, U> {
                 const collectionName = refModelInstance.collection.name
 
                 // Determinar el campo local correcto según si es un solo campo o múltiples
-                const localField = totalGroupFields === 1 ? '_id' : `_id.${fieldName}`
+                const localField = totalGroupFields === 1 ? '_id' : `_id.${fieldAlias}`
 
-                lookupStages.push({
+                postGroupStages.push({
                     $lookup: {
                         from: collectionName,
                         localField: localField,
                         foreignField: '_id',
-                        as: `${fieldName}_populated`
+                        as: `${fieldAlias}_populated`
                     }
                 })
 
                 // Unwind para convertir el array en objeto único
-                lookupStages.push({
+                postGroupStages.push({
                     $unwind: {
-                        path: `$${fieldName}_populated`,
+                        path: `$${fieldAlias}_populated`,
                         preserveNullAndEmptyArrays: true
                     }
                 })
 
                 // En la proyección final, usar el objeto poblado
-                finalProjectFields[field] = `$${fieldName}_populated`
-                groupId[field] = `$${field}`
+                finalProjectFields[field] = `$${fieldAlias}_populated`
+                groupId[fieldAlias] = `$${field}`
+            } else if (nestedFieldPath && rootSchemaPath && rootSchemaPath.options && rootSchemaPath.options.ref) {
+                const lookupAlias = ensureLookupForReferencedField(rootField, rootSchemaPath.options.ref)
+                groupId[fieldAlias] = `$${lookupAlias}.${nestedFieldPath}`
             } else {
                 // Si no es una referencia ni fecha, usar el valor directo
-                groupId[field] = `$${field}`
+                groupId[fieldAlias] = `$${field}`
             }
         })
 
         // Construir la proyección final para campos de fecha
         groupFields.forEach(field => {
+            const fieldAlias = groupFieldAliases.get(field) as string
             if (dateFields.has(field)) {
                 if (groupFields.length === 1) {
                     finalProjectFields[field] = `$_id`
                 } else {
-                    finalProjectFields[field] = `$_id.${field}`
+                    finalProjectFields[field] = `$_id.${fieldAlias}`
                 }
             } else if (!refFields.has(field)) {
                 if (groupFields.length === 1) {
                     finalProjectFields[field] = `$_id`
                 } else {
-                    finalProjectFields[field] = `$_id.${field}`
+                    finalProjectFields[field] = `$_id.${fieldAlias}`
                 }
             }
         })
@@ -489,21 +545,23 @@ class AbstractMongoRepository<T, C, U> implements IDraxCrud<T, C, U> {
 
         if (groupFields.length === 1) {
             const field = groupFields[0]
-            groupStage._id = dateFields.has(field) ? getDateFormat(field, dateFormat) : groupId[field]
+            const fieldAlias = groupFieldAliases.get(field) as string
+            groupStage._id = dateFields.has(field) ? getDateFormat(field, dateFormat) : groupId[fieldAlias]
         } else if (groupFields.length > 1) {
             groupStage._id = groupId
         }
 
         const pipeline: any[] = [
             {$match: query},
+            ...preGroupStages,
             {
                 $group: groupStage
             }
         ]
 
         // Solo agregar lookups si hay campos de referencia
-        if (lookupStages.length > 0) {
-            pipeline.push(...lookupStages)
+        if (postGroupStages.length > 0) {
+            pipeline.push(...postGroupStages)
         }
 
         pipeline.push(
@@ -514,7 +572,23 @@ class AbstractMongoRepository<T, C, U> implements IDraxCrud<T, C, U> {
         )
         // console.log("pipeline", JSON.stringify(pipeline, null, 2))
         const result = await this._model.aggregate(pipeline).exec()
-        return result
+
+        return result.map((item: any) => {
+            const normalizedItem = {...item}
+
+            groupFields.forEach(field => {
+                if (!field.includes('.') || normalizedItem[field] !== undefined) {
+                    return
+                }
+
+                const nestedValue = this.getNestedValue(normalizedItem, field)
+                if (nestedValue !== undefined) {
+                    normalizedItem[field] = nestedValue
+                }
+            })
+
+            return normalizedItem
+        })
     }
 }
 

package/test/controllers/PersonController.test.ts

@@ -561,6 +561,122 @@ describe("Person Controller Test", function () {
         expect(groupResult.length).toBeGreaterThan(0)
     })
 
+    it("should groupBy nested reference and embedded fields together", async () => {
+        const { accessToken } = await testSetup.rootUserLogin()
+        await testSetup.dropCollection('Person')
+        await testSetup.dropCollection('Country')
+
+        const argentina = await CountryModel.create({
+            name: "Argentina",
+            createdBy: testSetup.rootUser._id
+        })
+
+        const chile = await CountryModel.create({
+            name: "Chile",
+            createdBy: testSetup.rootUser._id
+        })
+
+        const entityData: IPersonBase[] = [
+            {
+                fullname: "Buenos Aires One",
+                nationality: argentina._id.toString(),
+                address: { street: "Main St", city: "Buenos Aires" }
+            },
+            {
+                fullname: "Buenos Aires Two",
+                nationality: argentina._id.toString(),
+                address: { street: "Second St", city: "Buenos Aires" }
+            },
+            {
+                fullname: "Santiago One",
+                nationality: chile._id.toString(),
+                address: { street: "Main St", city: "Santiago" }
+            }
+        ]
+
+        for (const data of entityData) {
+            const createResp = await testSetup.fastifyInstance.inject({
+                method: 'POST',
+                url: '/api/person',
+                payload: data,
+                headers: { Authorization: `Bearer ${accessToken}` }
+            })
+
+            expect(createResp.statusCode).toBe(200)
+        }
+
+        const groupResp = await testSetup.fastifyInstance.inject({
+            method: 'GET',
+            url: '/api/person/group-by?fields=nationality.name,address.city',
+            headers: { Authorization: `Bearer ${accessToken}` }
+        })
+
+        const groupResult = await groupResp.json()
+        expect(groupResp.statusCode).toBe(200)
+        expect(groupResult).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                'nationality.name': 'Argentina',
+                'address.city': 'Buenos Aires',
+                count: 2
+            }),
+            expect.objectContaining({
+                'nationality.name': 'Chile',
+                'address.city': 'Santiago',
+                count: 1
+            })
+        ]))
+    })
+
+    it("should groupBy a single embedded nested field", async () => {
+        const { accessToken } = await testSetup.rootUserLogin()
+        await testSetup.dropCollection('Person')
+
+        const entityData: IPersonBase[] = [
+            {
+                fullname: "Argentina One",
+                address: { street: "Main St", country: "Argentina", city: "Buenos Aires" }
+            },
+            {
+                fullname: "Argentina Two",
+                address: { street: "Second St", country: "Argentina", city: "Cordoba" }
+            },
+            {
+                fullname: "Chile One",
+                address: { street: "Third St", country: "Chile", city: "Santiago" }
+            }
+        ]
+
+        for (const data of entityData) {
+            const createResp = await testSetup.fastifyInstance.inject({
+                method: 'POST',
+                url: '/api/person',
+                payload: data,
+                headers: { Authorization: `Bearer ${accessToken}` }
+            })
+
+            expect(createResp.statusCode).toBe(200)
+        }
+
+        const groupResp = await testSetup.fastifyInstance.inject({
+            method: 'GET',
+            url: '/api/person/group-by?fields=address.country',
+            headers: { Authorization: `Bearer ${accessToken}` }
+        })
+
+        const groupResult = await groupResp.json()
+        expect(groupResp.statusCode).toBe(200)
+        expect(groupResult).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                'address.country': 'Argentina',
+                count: 2
+            }),
+            expect.objectContaining({
+                'address.country': 'Chile',
+                count: 1
+            })
+        ]))
+    })
+
     // 9. Error Handling - Not Found
     it("should handle error responses correctly when person is not found", async () => {
         const { accessToken } = await testSetup.rootUserLogin()