@drax/crud-back 0.36.0 → 0.37.0

package/src/repository/AbstractMongoRepository.ts

@@ -1,3 +1,4 @@
+
 import "mongoose-paginate-v2";
 import mongoose from "mongoose";
 import type {Cursor, PopulateOptions} from "mongoose";
@@ -9,7 +10,14 @@ import {
     MongoServerErrorToValidationError
 } from "@drax/common-back";
 import type {DeleteResult} from "mongodb";
-import type {IDraxPaginateOptions, IDraxPaginateResult, IDraxFindOptions, IDraxCrud, IDraxFieldFilter} from "@drax/crud-share";
+import type {
+    IDraxPaginateOptions,
+    IDraxPaginateResult,
+    IDraxFindOptions,
+    IDraxCrud,
+    IDraxFieldFilter,
+    IDraxGroupByOptions
+} from "@drax/crud-share";
 import type {PaginateModel, PaginateOptions, PaginateResult} from "mongoose";
 import {InvalidIdError} from "@drax/common-back";
 import {MongoServerError} from "mongodb";
@@ -19,11 +27,11 @@ class AbstractMongoRepository<T, C, U> implements IDraxCrud<T, C, U> {
 
     protected _model: mongoose.Model<T> & PaginateModel<T>
     protected _searchFields: string[] = []
-    protected _populateFields:  string[] | PopulateOptions[] = []
+    protected _populateFields: string[] | PopulateOptions[] = []
     protected _lean: boolean = true
 
     assertId(id: string): void {
-        if(!mongoose.Types.ObjectId.isValid(id)){
+        if (!mongoose.Types.ObjectId.isValid(id)) {
             console.log(`Invalid ID: ${id} is not a valid ObjectId.`)
             throw new InvalidIdError(id)
         }
@@ -34,7 +42,7 @@ class AbstractMongoRepository<T, C, U> implements IDraxCrud<T, C, U> {
         try {
             const item: mongoose.HydratedDocument<T> = await this._model.create(data)
 
-            if(this._populateFields && this._populateFields.length > 0){
+            if (this._populateFields && this._populateFields.length > 0) {
                 //@ts-ignore
                 await item.populate(this._populateFields)
             }
@@ -46,7 +54,7 @@ class AbstractMongoRepository<T, C, U> implements IDraxCrud<T, C, U> {
             if (e instanceof mongoose.Error.CastError) {
                 throw MongooseCastErrorToValidationError(e)
             }
-            if(e instanceof MongoServerError || e.name === 'MongoServerError'){
+            if (e instanceof MongoServerError || e.name === 'MongoServerError') {
                 throw MongoServerErrorToValidationError(e)
             }
             throw e
@@ -68,7 +76,7 @@ class AbstractMongoRepository<T, C, U> implements IDraxCrud<T, C, U> {
             if (e instanceof mongoose.Error.CastError) {
                 throw MongooseCastErrorToValidationError(e)
             }
-            if(e instanceof MongoServerError || e.name === 'MongoServerError'){
+            if (e instanceof MongoServerError || e.name === 'MongoServerError') {
                 throw MongoServerErrorToValidationError(e)
             }
             throw e
@@ -90,7 +98,7 @@ class AbstractMongoRepository<T, C, U> implements IDraxCrud<T, C, U> {
             if (e instanceof mongoose.Error.CastError) {
                 throw MongooseCastErrorToValidationError(e)
             }
-            if(e instanceof MongoServerError || e.name === 'MongoServerError'){
+            if (e instanceof MongoServerError || e.name === 'MongoServerError') {
                 throw MongoServerErrorToValidationError(e)
             }
             throw e
@@ -116,7 +124,7 @@ class AbstractMongoRepository<T, C, U> implements IDraxCrud<T, C, U> {
 
     async findByIds(ids: Array<string>): Promise<T[]> {
 
-        ids.map(id =>  this.assertId(id))
+        ids.map(id => this.assertId(id))
 
         const items = await this._model
             .find({_id: {$in: ids}})
@@ -141,7 +149,7 @@ class AbstractMongoRepository<T, C, U> implements IDraxCrud<T, C, U> {
         return item as T
     }
 
-    async findBy(field: string, value: any, limit: number  = 0): Promise<T[]> {
+    async findBy(field: string, value: any, limit: number = 0): Promise<T[]> {
         const filter: any = {[field]: value}
         const items = await this._model
             .find(filter)
@@ -166,13 +174,13 @@ class AbstractMongoRepository<T, C, U> implements IDraxCrud<T, C, U> {
         return items as T[]
     }
 
-    async search(value: string, limit: number = 1000, filters: IDraxFieldFilter[] =[]): Promise<T[]> {
+    async search(value: string, limit: number = 1000, filters: IDraxFieldFilter[] = []): Promise<T[]> {
 
         const query = {}
 
-        if(mongoose.Types.ObjectId.isValid(value)) {
+        if (mongoose.Types.ObjectId.isValid(value)) {
             query['_id'] = new mongoose.Types.ObjectId(value)
-        }else if (value) {
+        } else if (value) {
             query['$or'] = this._searchFields.map(field => ({[field]: new RegExp(value.toString(), 'i')}))
         }
 
@@ -201,10 +209,10 @@ class AbstractMongoRepository<T, C, U> implements IDraxCrud<T, C, U> {
 
         const query = {}
 
-        if(search){
-            if(mongoose.Types.ObjectId.isValid(search)) {
+        if (search) {
+            if (mongoose.Types.ObjectId.isValid(search)) {
                 query['_id'] = new mongoose.Types.ObjectId(search)
-            }else{
+            } else {
                 query['$or'] = this._searchFields.map(field => ({[field]: new RegExp(search.toString(), 'i')}))
             }
         }
@@ -225,23 +233,23 @@ class AbstractMongoRepository<T, C, U> implements IDraxCrud<T, C, U> {
     }
 
     async findOne({
-                   search = '',
-                   filters = []
-               }: IDraxFindOptions): Promise<T> {
+                      search = '',
+                      filters = []
+                  }: IDraxFindOptions): Promise<T> {
 
         const query = {}
 
-        if(search){
-            if(mongoose.Types.ObjectId.isValid(search)) {
+        if (search) {
+            if (mongoose.Types.ObjectId.isValid(search)) {
                 query['_id'] = new mongoose.Types.ObjectId(search)
-            }else{
+            } else {
                 query['$or'] = this._searchFields.map(field => ({[field]: new RegExp(search.toString(), 'i')}))
             }
         }
 
         MongooseQueryFilter.applyFilters(query, filters)
 
-        const item =  this._model
+        const item = this._model
             .findOne(query)
             .populate(this._populateFields)
             .lean(this._lean)
@@ -260,10 +268,10 @@ class AbstractMongoRepository<T, C, U> implements IDraxCrud<T, C, U> {
 
         const query = {}
 
-        if(search){
-            if(mongoose.Types.ObjectId.isValid(search)) {
+        if (search) {
+            if (mongoose.Types.ObjectId.isValid(search)) {
                 query['_id'] = new mongoose.Types.ObjectId(search)
-            }else{
+            } else {
                 query['$or'] = this._searchFields.map(field => ({[field]: new RegExp(search.toString(), 'i')}))
             }
         }
@@ -271,7 +279,7 @@ class AbstractMongoRepository<T, C, U> implements IDraxCrud<T, C, U> {
         MongooseQueryFilter.applyFilters(query, filters)
 
         const sort = MongooseSort.applySort(orderBy, order)
-        const items =  await this._model
+        const items = await this._model
             .find(query)
             .limit(limit)
             .sort(sort)
@@ -305,6 +313,168 @@ class AbstractMongoRepository<T, C, U> implements IDraxCrud<T, C, U> {
 
         return this._model.find(query).limit(limit).sort(sort).cursor() as Cursor<T>;
     }
+
+    async groupBy({fields = [], filters = [], dateFormat = 'day'}: IDraxGroupByOptions): Promise<Array<any>> {
+
+        const query = {}
+
+        MongooseQueryFilter.applyFilters(query, filters)
+
+        // Obtener el schema para identificar campos de referencia y fechas
+        const schema = this._model.schema
+
+        // Construir el objeto de agrupación dinámicamente
+        const groupId: any = {}
+        const lookupStages: any[] = []
+        const finalProjectFields: any = {count: 1, _id: 0}
+        const refFields = new Set<string>()
+        const dateFields = new Set<string>()
+
+        // Función para obtener el formato de fecha según el nivel de granularidad
+        const getDateFormat = (field: string, format: string) => {
+            const formats = {
+                'year': {
+                    $dateFromParts: {
+                        year: {$year: `$${field}`},
+                        month: 1,
+                        day: 1
+                    }
+                },
+                'month': {
+                    $dateFromParts: {
+                        year: {$year: `$${field}`},
+                        month: {$month: `$${field}`},
+                        day: 1
+                    }
+                },
+                'day': {
+                    $dateFromParts: {
+                        year: {$year: `$${field}`},
+                        month: {$month: `$${field}`},
+                        day: {$dayOfMonth: `$${field}`}
+                    }
+                },
+                'hour': {
+                    $dateFromParts: {
+                        year: {$year: `$${field}`},
+                        month: {$month: `$${field}`},
+                        day: {$dayOfMonth: `$${field}`},
+                        hour: {$hour: `$${field}`}
+                    }
+                },
+                'minute': {
+                    $dateFromParts: {
+                        year: {$year: `$${field}`},
+                        month: {$month: `$${field}`},
+                        day: {$dayOfMonth: `$${field}`},
+                        hour: {$hour: `$${field}`},
+                        minute: {$minute: `$${field}`}
+                    }
+                },
+                'second': {
+                    $dateFromParts: {
+                        year: {$year: `$${field}`},
+                        month: {$month: `$${field}`},
+                        day: {$dayOfMonth: `$${field}`},
+                        hour: {$hour: `$${field}`},
+                        minute: {$minute: `$${field}`},
+                        second: {$second: `$${field}`}
+                    }
+                }
+            }
+            return formats[format] || formats['day']
+        }
+
+        fields.forEach(field => {
+            const schemaPath = schema.path(field)
+
+            // Verificar si el campo es de tipo Date
+            if (schemaPath && schemaPath.instance === 'Date') {
+                dateFields.add(field)
+                groupId[field] = 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 = fields.length === 1 ? '_id' : `_id.${fieldName}`
+
+                lookupStages.push({
+                    $lookup: {
+                        from: collectionName,
+                        localField: localField,
+                        foreignField: '_id',
+                        as: `${fieldName}_populated`
+                    }
+                })
+
+                // Unwind para convertir el array en objeto único
+                lookupStages.push({
+                    $unwind: {
+                        path: `$${fieldName}_populated`,
+                        preserveNullAndEmptyArrays: true
+                    }
+                })
+
+                // En la proyección final, usar el objeto poblado
+                finalProjectFields[field] = `$${fieldName}_populated`
+                groupId[field] = `$${field}`
+            } else {
+                // Si no es una referencia ni fecha, usar el valor directo
+                groupId[field] = `$${field}`
+            }
+        })
+
+        // Construir la proyección final para campos de fecha
+        fields.forEach(field => {
+            if (dateFields.has(field)) {
+                if (fields.length === 1) {
+                    finalProjectFields[field] = `$_id`
+                } else {
+                    finalProjectFields[field] = `$_id.${field}`
+                }
+            } else if (!refFields.has(field)) {
+                if (fields.length === 1) {
+                    finalProjectFields[field] = `$_id`
+                } else {
+                    finalProjectFields[field] = `$_id.${field}`
+                }
+            }
+        })
+
+        const pipeline: any[] = [
+            {$match: query},
+            {
+                $group: {
+                    _id: fields.length === 1 ? (dateFields.has(fields[0]) ? getDateFormat(fields[0], dateFormat) : `$${fields[0]}`) : groupId,
+                    count: {$sum: 1}
+                }
+            }
+        ]
+
+        // Solo agregar lookups si hay campos de referencia
+        if (lookupStages.length > 0) {
+            pipeline.push(...lookupStages)
+        }
+
+        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
+    }
 }
 
 export default AbstractMongoRepository

package/src/schemas/GroupBySchema.ts

@@ -0,0 +1,10 @@
+import z from "zod"
+import QueryFilterRegex from "../regexs/QueryFilterRegex.js";
+
+const GroupByQuerySchema = z.object({
+    fields: z.array(z.string()).min(1).max(10),
+    filters:  z.string().regex(QueryFilterRegex).optional().describe("Format: field;operator;value|field;operator;value|..."),
+});
+
+
+export {GroupByQuerySchema}

package/src/services/AbstractService.ts

@@ -6,7 +6,7 @@ import type {
     IDraxPaginateResult,
     IDraxFindOptions,
     IDraxExportOptions,
-    IDraxCrudRepository, IDraxFieldFilter
+    IDraxCrudRepository, IDraxFieldFilter, IDraxGroupByOptions
 } from "@drax/crud-share";
 import {IDraxCrudService} from "@drax/crud-share";
 import ExportCsv from "../exports/ExportCsv.js";
@@ -262,6 +262,10 @@ abstract class AbstractService<T, C, U> implements IDraxCrudService<T, C, U> {
 
     }
 
+    async groupBy({fields= [], filters= [], dateFormat= 'day'}: IDraxGroupByOptions): Promise<Array<any>> {
+        return await this._repository.groupBy({fields, filters, dateFormat})
+    }
+
     async export({
                      format = 'JSON',
                      headers = [],