@drax/crud-back 2.8.0 → 2.11.0

package/dist/controllers/AbstractFastifyController.js

@@ -43,7 +43,7 @@ class AbstractFastifyController extends CommonController {
             const filters = [];
             filterArray.forEach((filter) => {
                 const [field, operator, value] = filter.split(";");
-                if (field && operator && (value !== undefined && value !== '')) {
+                if (field && operator && (operator === 'empty' || (value !== undefined && value !== ''))) {
                     filters.push({ field, operator, value });
                 }
             });

package/dist/regexs/QueryFilterRegex.js

@@ -1,3 +1,3 @@
-const QueryFilterRegex = /^(?:[a-zA-Z0-9_.\-]+;(?:eq|like|ne|in|nin|gt|gte|lt|lte);[a-zA-Z0-9_.\-:\., áéíóúÁÉÍÓÚ]*)(?:\|[a-zA-Z0-9_.\-]+;(?:eq|like|ne|in|nin|gt|gte|lt|lte);[a-zA-Z0-9_.\-:\., áéíóúÁÉÍÓÚ]*)*$/;
+const QueryFilterRegex = /^(?:[a-zA-Z0-9_.\-]+;(?:eq|like|ne|in|nin|gt|gte|lt|lte|empty);[a-zA-Z0-9_.\-:\., áéíóúÁÉÍÓÚ]*)(?:\|[a-zA-Z0-9_.\-]+;(?:eq|like|ne|in|nin|gt|gte|lt|lte|empty);[a-zA-Z0-9_.\-:\., áéíóúÁÉÍÓÚ]*)*$/;
 export default QueryFilterRegex;
 export { QueryFilterRegex };

package/dist/repository/AbstractMongoRepository.js

@@ -133,7 +133,7 @@ class AbstractMongoRepository {
         else if (value) {
             query['$or'] = this._searchFields.map(field => ({ [field]: new RegExp(value.toString(), 'i') }));
         }
-        MongooseQueryFilter.applyFilters(query, filters);
+        MongooseQueryFilter.applyFilters(query, filters, this._model);
         const items = await this._model
             .find(query)
             .limit(limit)
@@ -152,7 +152,7 @@ class AbstractMongoRepository {
                 query['$or'] = this._searchFields.map(field => ({ [field]: new RegExp(search.toString(), 'i') }));
             }
         }
-        MongooseQueryFilter.applyFilters(query, filters);
+        MongooseQueryFilter.applyFilters(query, filters, this._model);
         // console.log("Paginate Query", query)
         const sort = MongooseSort.applySort(orderBy, order);
         const populate = this._populateFields;
@@ -176,7 +176,7 @@ class AbstractMongoRepository {
                 query['$or'] = this._searchFields.map(field => ({ [field]: new RegExp(search.toString(), 'i') }));
             }
         }
-        MongooseQueryFilter.applyFilters(query, filters);
+        MongooseQueryFilter.applyFilters(query, filters, this._model);
         const item = this._model
             .findOne(query)
             .populate(this._populateFields)
@@ -194,7 +194,7 @@ class AbstractMongoRepository {
                 query['$or'] = this._searchFields.map(field => ({ [field]: new RegExp(search.toString(), 'i') }));
             }
         }
-        MongooseQueryFilter.applyFilters(query, filters);
+        MongooseQueryFilter.applyFilters(query, filters, this._model);
         const sort = MongooseSort.applySort(orderBy, order);
         const items = await this._model
             .find(query)
@@ -212,14 +212,14 @@ class AbstractMongoRepository {
                 { name: new RegExp(search, 'i') },
             ];
         }
-        MongooseQueryFilter.applyFilters(query, filters);
+        MongooseQueryFilter.applyFilters(query, filters, this._model);
         const sort = MongooseSort.applySort(orderBy, order);
         return this._model.find(query).limit(limit).sort(sort).cursor();
     }
     async groupBy({ fields = [], filters = [], dateFormat = 'day' }) {
         const query = {};
-        MongooseQueryFilter.applyFilters(query, filters);
-        //  console.log("groupBy Query", query)
+        MongooseQueryFilter.applyFilters(query, filters, this._model);
+        // console.log("groupBy Query", query)
         // Obtener el schema para identificar campos de referencia y fechas
         const schema = this._model.schema;
         // Construir el objeto de agrupación dinámicamente
@@ -228,6 +228,13 @@ class AbstractMongoRepository {
         const finalProjectFields = { count: 1, _id: 0 };
         const refFields = new Set();
         const dateFields = new Set();
+        const numericFields = new Set();
+        const groupFields = [];
+        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;
         // Función para obtener el formato de fecha según el nivel de granularidad
         const getDateFormat = (field, format) => {
             const formats = {
@@ -284,6 +291,13 @@ class AbstractMongoRepository {
         };
         fields.forEach(field => {
             const schemaPath = schema.path(field);
+            // 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);
+                finalProjectFields[field] = 1;
+                return;
+            }
+            groupFields.push(field);
             // Verificar si el campo es de tipo Date
             if (schemaPath && schemaPath.instance === 'Date') {
                 dateFields.add(field);
@@ -298,7 +312,7 @@ class AbstractMongoRepository {
                 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 = fields.length === 1 ? '_id' : `_id.${fieldName}`;
+                const localField = totalGroupFields === 1 ? '_id' : `_id.${fieldName}`;
                 lookupStages.push({
                     $lookup: {
                         from: collectionName,
@@ -324,9 +338,9 @@ class AbstractMongoRepository {
             }
         });
         // Construir la proyección final para campos de fecha
-        fields.forEach(field => {
+        groupFields.forEach(field => {
             if (dateFields.has(field)) {
-                if (fields.length === 1) {
+                if (groupFields.length === 1) {
                     finalProjectFields[field] = `$_id`;
                 }
                 else {
@@ -334,7 +348,7 @@ class AbstractMongoRepository {
                 }
             }
             else if (!refFields.has(field)) {
-                if (fields.length === 1) {
+                if (groupFields.length === 1) {
                     finalProjectFields[field] = `$_id`;
                 }
                 else {
@@ -342,13 +356,24 @@ class AbstractMongoRepository {
                 }
             }
         });
+        const groupStage = {
+            _id: null,
+            count: { $sum: 1 }
+        };
+        numericFields.forEach(field => {
+            groupStage[field] = { $sum: { $ifNull: [`$${field}`, 0] } };
+        });
+        if (groupFields.length === 1) {
+            const field = groupFields[0];
+            groupStage._id = dateFields.has(field) ? getDateFormat(field, dateFormat) : groupId[field];
+        }
+        else if (groupFields.length > 1) {
+            groupStage._id = groupId;
+        }
         const pipeline = [
             { $match: query },
             {
-                $group: {
-                    _id: fields.length === 1 ? (dateFields.has(fields[0]) ? getDateFormat(fields[0], dateFormat) : `$${fields[0]}`) : groupId,
-                    count: { $sum: 1 }
-                }
+                $group: groupStage
             }
         ];
         // Solo agregar lookups si hay campos de referencia

package/dist/repository/AbstractSqliteRepository.js

@@ -132,41 +132,61 @@ class AbstractSqliteRepository {
     async paginate({ page = 1, limit = 5, orderBy = '', order = 'desc', search = '', filters = [] }) {
         const offset = page > 1 ? (page - 1) * limit : 0;
         let where = "";
+        let params = [];
+        // SEARCH
         if (search && this.searchFields.length > 0) {
-            where = ` WHERE ${this.searchFields.map(field => `${field} LIKE '%${search}%'`).join(" OR ")}`;
+            const searchConditions = this.searchFields
+                .map(field => `${field} LIKE ?`)
+                .join(" OR ");
+            where = ` WHERE (${searchConditions})`;
+            params.push(...this.searchFields.map(() => `%${search}%`));
         }
+        // FILTERS
         if (filters.length > 0) {
-            where = SqlQueryFilter.applyFilters(where, filters);
+            const result = SqlQueryFilter.applyFilters(where, filters);
+            where = result.where;
+            params.push(...result.params);
         }
         const sort = SqlSort.applySort(orderBy, order);
-        const rCount = this.db.prepare(`SELECT COUNT(*) as count
-                                        FROM ${this.tableName} ${where}`).get();
-        const items = this.db.prepare(`SELECT *
-                                       FROM ${this.tableName} ${where} ${sort} LIMIT ?
-                                       OFFSET ? `).all([limit, offset]);
+        // COUNT
+        const rCount = this.db
+            .prepare(`SELECT COUNT(*) as count FROM ${this.tableName} ${where}`)
+            .get(params);
+        // DATA
+        const items = this.db
+            .prepare(`SELECT * FROM ${this.tableName} ${where} ${sort} LIMIT ? OFFSET ?`)
+            .all([...params, limit, offset]);
         for (const item of items) {
             await this.decorate(item);
         }
         return {
-            page: page,
-            limit: limit,
+            page,
+            limit,
             total: rCount.count,
-            items: items
+            items
         };
     }
     async find({ limit = 5, orderBy = '', order = 'desc', search = '', filters = [] }) {
         let where = "";
+        let params = [];
+        // SEARCH
         if (search && this.searchFields.length > 0) {
-            where = ` WHERE ${this.searchFields.map(field => `${field} LIKE '%${search}%'`).join(" OR ")}`;
+            const searchConditions = this.searchFields
+                .map(field => `${field} LIKE ?`)
+                .join(" OR ");
+            where = ` WHERE (${searchConditions})`;
+            params.push(...this.searchFields.map(() => `%${search}%`));
         }
+        // FILTERS
         if (filters.length > 0) {
-            where = SqlQueryFilter.applyFilters(where, filters);
+            const result = SqlQueryFilter.applyFilters(where, filters);
+            where = result.where;
+            params.push(...result.params);
         }
         const sort = SqlSort.applySort(orderBy, order);
-        const rCount = this.db.prepare(`SELECT COUNT(*) as count
-                                        FROM ${this.tableName} ${where}`).get();
-        const items = this.db.prepare(`SELECT *
-                                       FROM ${this.tableName} ${where} ${sort} LIMIT ? `).all([limit]);
+        const items = this.db
+            .prepare(`SELECT * FROM ${this.tableName} ${where} ${sort} LIMIT ?`)
+            .all([...params, limit]);
         for (const item of items) {
             await this.decorate(item);
         }
@@ -182,11 +202,17 @@ class AbstractSqliteRepository {
     }
     async search(value, limit = 1000) {
         let where = "";
+        let params = [];
         if (value && this.searchFields.length > 0) {
-            where = ` WHERE ${this.searchFields.map(field => `${field} LIKE '%${value}%'`).join(" OR ")}`;
+            const searchConditions = this.searchFields
+                .map(field => `${field} LIKE ?`)
+                .join(" OR ");
+            where = ` WHERE (${searchConditions})`;
+            params.push(...this.searchFields.map(() => `%${value}%`));
         }
-        const items = this.db.prepare(`SELECT *
-                                       FROM ${this.tableName} ${where} LIMIT ${limit}`).all();
+        const items = this.db
+            .prepare(`SELECT * FROM ${this.tableName} ${where} LIMIT ?`)
+            .all([...params, limit]);
         for (const item of items) {
             await this.decorate(item);
         }
@@ -217,14 +243,24 @@ class AbstractSqliteRepository {
     }
     async findOne({ search = '', filters = [] }) {
         let where = "";
+        let params = [];
+        // SEARCH
         if (search && this.searchFields.length > 0) {
-            where = ` WHERE ${this.searchFields.map(field => `${field} LIKE '%${search}%'`).join(" OR ")}`;
+            const searchConditions = this.searchFields
+                .map(field => `${field} LIKE ?`)
+                .join(" OR ");
+            where = ` WHERE (${searchConditions})`;
+            params.push(...this.searchFields.map(() => `%${search}%`));
         }
+        // FILTERS
         if (filters.length > 0) {
-            where = SqlQueryFilter.applyFilters(where, filters);
+            const result = SqlQueryFilter.applyFilters(where, filters);
+            where = result.where;
+            params.push(...result.params);
         }
-        const item = this.db.prepare(`SELECT *
-                                      FROM ${this.tableName} ${where} LIMIT 1`).get();
+        const item = this.db
+            .prepare(`SELECT * FROM ${this.tableName} ${where} LIMIT 1`)
+            .get(params);
         if (item) {
             await this.decorate(item);
         }
@@ -234,12 +270,13 @@ class AbstractSqliteRepository {
         if (fields.length === 0) {
             throw new Error("At least one field is required for groupBy");
         }
-        // Construir la cláusula WHERE con los filtros
         let where = "";
+        let params = [];
         if (filters.length > 0) {
-            where = SqlQueryFilter.applyFilters(where, filters);
+            const result = SqlQueryFilter.applyFilters(where, filters);
+            where = result.where;
+            params.push(...result.params);
         }
-        // Función para obtener el formato de fecha según SQLite
         const getDateFormatSQL = (field, format) => {
             const formats = {
                 'year': `strftime('%Y', ${field})`,
@@ -251,39 +288,53 @@ class AbstractSqliteRepository {
             };
             return formats[format] || formats['day'];
         };
-        // Determinar si cada campo es de fecha
         const isDateField = (field) => {
             const tableField = this.tableFields.find(tf => tf.name === field);
-            return tableField ? tableField.type === 'TEXT' && (field.includes('Date') || field.includes('date')) : false;
+            return tableField
+                ? tableField.type === 'TEXT' && (field.includes('Date') || field.includes('date'))
+                : false;
         };
-        // Construir los campos SELECT con formato de fecha si aplica
-        const selectFields = fields.map(field => {
-            if (isDateField(field)) {
-                return `${getDateFormatSQL(field, dateFormat)} as ${field}`;
+        const isNumericField = (field) => {
+            const tableField = this.tableFields.find(tf => tf.name === field);
+            if (!tableField)
+                return false;
+            const type = tableField.type.toUpperCase();
+            return ['INTEGER', 'REAL', 'NUMERIC'].includes(type);
+        };
+        const selectParts = [];
+        const groupParts = [];
+        for (const field of fields) {
+            const tableField = this.tableFields.find(tf => tf.name === field);
+            if (!tableField) {
+                throw new Error(`Invalid field ${field}`);
+            }
+            if (isNumericField(field)) {
+                selectParts.push(`SUM(${field}) as ${field}`);
+                continue;
             }
-            return field;
-        }).join(', ');
-        // Construir la cláusula GROUP BY
-        const groupByFields = fields.map(field => {
             if (isDateField(field)) {
-                return getDateFormatSQL(field, dateFormat);
+                const formatted = getDateFormatSQL(field, dateFormat);
+                selectParts.push(`${formatted} as ${field}`);
+                groupParts.push(formatted);
+                continue;
             }
-            return field;
-        }).join(', ');
-        // Construir y ejecutar la query
+            selectParts.push(field);
+            groupParts.push(field);
+        }
+        const selectFields = selectParts.join(", ");
+        const groupByFields = groupParts.join(", ");
         const query = `
-            SELECT ${selectFields}, COUNT(*) as count
-            FROM ${this.tableName}
-            ${where}
-            GROUP BY ${groupByFields}
-            ORDER BY count DESC
-        `;
+        SELECT ${selectFields}, COUNT(*) as count
+        FROM ${this.tableName}
+        ${where}
+        ${groupByFields ? `GROUP BY ${groupByFields}` : ''}
+        ORDER BY count DESC
+    `;
         try {
-            const result = this.db.prepare(query).all();
-            // Decorar los items si tienen campos de población
-            for (const item of result) {
-                await this.decorate(item);
-            }
+            const result = this.db.prepare(query).all(params);
+            // for (const item of result) {
+            //     await this.decorate(item)
+            // }
             return result;
         }
         catch (e) {

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "2.8.0",
+  "version": "2.11.0",
   "description": "Crud utils across modules",
   "main": "dist/index.js",
   "types": "types/index.d.ts",
@@ -22,10 +22,10 @@
   "author": "Cristian Incarnato & Drax Team",
   "license": "ISC",
   "dependencies": {
-    "@drax/common-back": "^2.8.0",
+    "@drax/common-back": "^2.11.0",
     "@drax/common-share": "^2.0.0",
     "@drax/identity-share": "^2.0.0",
-    "@drax/media-back": "^2.8.0",
+    "@drax/media-back": "^2.11.0",
     "@graphql-tools/load-files": "^7.0.0",
     "@graphql-tools/merge": "^9.0.4",
     "mongoose": "^8.23.0",
@@ -46,5 +46,5 @@
     "tsc-alias": "^1.8.10",
     "typescript": "^5.9.3"
   },
-  "gitHead": "3adeb31ee60eb83c92137dc28162f9226cab06c1"
+  "gitHead": "8919d31d4d9512e48ac461b0876dc85a5849daea"
 }

package/src/controllers/AbstractFastifyController.ts

@@ -114,7 +114,7 @@ class AbstractFastifyController<T, C, U> extends CommonController {
             filterArray.forEach((filter) => {
                 const [field, operator, value] = filter.split(";")
 
-                if(field && operator && (value !== undefined && value !== '') ) {
+                if(field && operator && ( operator === 'empty' || (value !== undefined && value !== '')) ) {
                     filters.push({field, operator, value})
                 }
 

package/src/regexs/QueryFilterRegex.ts

@@ -1,4 +1,4 @@
-const QueryFilterRegex = /^(?:[a-zA-Z0-9_.\-]+;(?:eq|like|ne|in|nin|gt|gte|lt|lte);[a-zA-Z0-9_.\-:\., áéíóúÁÉÍÓÚ]*)(?:\|[a-zA-Z0-9_.\-]+;(?:eq|like|ne|in|nin|gt|gte|lt|lte);[a-zA-Z0-9_.\-:\., áéíóúÁÉÍÓÚ]*)*$/
+const QueryFilterRegex = /^(?:[a-zA-Z0-9_.\-]+;(?:eq|like|ne|in|nin|gt|gte|lt|lte|empty);[a-zA-Z0-9_.\-:\., áéíóúÁÉÍÓÚ]*)(?:\|[a-zA-Z0-9_.\-]+;(?:eq|like|ne|in|nin|gt|gte|lt|lte|empty);[a-zA-Z0-9_.\-:\., áéíóúÁÉÍÓÚ]*)*$/
 
 export default QueryFilterRegex
 export {QueryFilterRegex}

package/src/repository/AbstractMongoRepository.ts

@@ -184,7 +184,7 @@ class AbstractMongoRepository<T, C, U> implements IDraxCrud<T, C, U> {
             query['$or'] = this._searchFields.map(field => ({[field]: new RegExp(value.toString(), 'i')}))
         }
 
-        MongooseQueryFilter.applyFilters(query, filters)
+        MongooseQueryFilter.applyFilters(query, filters, this._model)
 
         const items = await this._model
             .find(query)
@@ -217,7 +217,7 @@ class AbstractMongoRepository<T, C, U> implements IDraxCrud<T, C, U> {
             }
         }
 
-        MongooseQueryFilter.applyFilters(query, filters)
+        MongooseQueryFilter.applyFilters(query, filters, this._model)
 
        // console.log("Paginate Query", query)
 
@@ -249,7 +249,7 @@ class AbstractMongoRepository<T, C, U> implements IDraxCrud<T, C, U> {
             }
         }
 
-        MongooseQueryFilter.applyFilters(query, filters)
+        MongooseQueryFilter.applyFilters(query, filters, this._model)
 
         const item = this._model
             .findOne(query)
@@ -278,7 +278,7 @@ class AbstractMongoRepository<T, C, U> implements IDraxCrud<T, C, U> {
             }
         }
 
-        MongooseQueryFilter.applyFilters(query, filters)
+        MongooseQueryFilter.applyFilters(query, filters, this._model)
 
         const sort = MongooseSort.applySort(orderBy, order)
         const items = await this._model
@@ -309,9 +309,9 @@ class AbstractMongoRepository<T, C, U> implements IDraxCrud<T, C, U> {
             ]
         }
 
-        MongooseQueryFilter.applyFilters(query, filters)
+        MongooseQueryFilter.applyFilters(query, filters, this._model)
 
-        const sort = MongooseSort.applySort(orderBy, order)
+        const sort = MongooseSort.applySort(orderBy, order,)
 
         return this._model.find(query).limit(limit).sort(sort).cursor() as Cursor<T>;
     }
@@ -320,8 +320,8 @@ class AbstractMongoRepository<T, C, U> implements IDraxCrud<T, C, U> {
 
         const query = {}
 
-        MongooseQueryFilter.applyFilters(query, filters)
-        //  console.log("groupBy Query", query)
+        MongooseQueryFilter.applyFilters(query, filters, this._model)
+          // console.log("groupBy Query", query)
 
         // Obtener el schema para identificar campos de referencia y fechas
         const schema = this._model.schema
@@ -332,6 +332,13 @@ class AbstractMongoRepository<T, C, U> implements IDraxCrud<T, C, U> {
         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 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
 
         // Función para obtener el formato de fecha según el nivel de granularidad
         const getDateFormat = (field: string, format: string) => {
@@ -391,6 +398,15 @@ class AbstractMongoRepository<T, C, U> implements IDraxCrud<T, C, U> {
         fields.forEach(field => {
             const schemaPath = schema.path(field)
 
+            // 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)
+                finalProjectFields[field] = 1
+                return
+            }
+
+            groupFields.push(field)
+
             // Verificar si el campo es de tipo Date
             if (schemaPath && schemaPath.instance === 'Date') {
                 dateFields.add(field)
@@ -408,7 +424,7 @@ 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 = fields.length === 1 ? '_id' : `_id.${fieldName}`
+                const localField = totalGroupFields === 1 ? '_id' : `_id.${fieldName}`
 
                 lookupStages.push({
                     $lookup: {
@@ -437,15 +453,15 @@ class AbstractMongoRepository<T, C, U> implements IDraxCrud<T, C, U> {
         })
 
         // Construir la proyección final para campos de fecha
-        fields.forEach(field => {
+        groupFields.forEach(field => {
             if (dateFields.has(field)) {
-                if (fields.length === 1) {
+                if (groupFields.length === 1) {
                     finalProjectFields[field] = `$_id`
                 } else {
                     finalProjectFields[field] = `$_id.${field}`
                 }
             } else if (!refFields.has(field)) {
-                if (fields.length === 1) {
+                if (groupFields.length === 1) {
                     finalProjectFields[field] = `$_id`
                 } else {
                     finalProjectFields[field] = `$_id.${field}`
@@ -453,13 +469,26 @@ class AbstractMongoRepository<T, C, U> implements IDraxCrud<T, C, U> {
             }
         })
 
+        const groupStage: any = {
+            _id: null,
+            count: {$sum: 1}
+        }
+
+        numericFields.forEach(field => {
+            groupStage[field] = {$sum: {$ifNull: [`$${field}`, 0]}}
+        })
+
+        if (groupFields.length === 1) {
+            const field = groupFields[0]
+            groupStage._id = dateFields.has(field) ? getDateFormat(field, dateFormat) : groupId[field]
+        } else if (groupFields.length > 1) {
+            groupStage._id = groupId
+        }
+
         const pipeline: any[] = [
             {$match: query},
             {
-                $group: {
-                    _id: fields.length === 1 ? (dateFields.has(fields[0]) ? getDateFormat(fields[0], dateFormat) : `$${fields[0]}`) : groupId,
-                    count: {$sum: 1}
-                }
+                $group: groupStage
             }
         ]