@drax/crud-back 0.36.0 → 0.37.2

package/dist/builders/CrudSchemaBuilder.js

@@ -1,6 +1,6 @@
 import z from 'zod';
 import { zodToJsonSchema } from 'zod-to-json-schema';
-import { IdParamSchema, DeleteBodyResponseSchema, PaginateQuerySchema, PaginateBodyResponseSchema, FindQuerySchema, SearchQuerySchema, FindByParamSchema, ErrorBodyResponseSchema, ValidationErrorBodyResponseSchema, ExportBodyResponseSchema } from '../index.js';
+import { IdParamSchema, DeleteBodyResponseSchema, PaginateQuerySchema, PaginateBodyResponseSchema, FindQuerySchema, SearchQuerySchema, FindByParamSchema, ErrorBodyResponseSchema, ValidationErrorBodyResponseSchema, ExportBodyResponseSchema, GroupByQuerySchema } from '../index.js';
 export class CrudSchemaBuilder {
     constructor(entitySchema, entityCreateSchema, entityUpdateSchema, entityName, target = 'openApi3', tags = []) {
         this.target = 'openApi3'; //"jsonSchema7" | "jsonSchema2019-09" | "openApi3" | "openAi"
@@ -29,6 +29,11 @@ export class CrudSchemaBuilder {
     get jsonEntityArraySchema() {
         return zodToJsonSchema(z.array(this.entitySchema), { target: this.target });
     }
+    get jsonEntityGroupBySchema() {
+        return zodToJsonSchema(z.array(z.object({
+            count: z.number()
+        }).catchall(z.any())), { target: this.target });
+    }
     get jsonExportBodyResponse() {
         return zodToJsonSchema(ExportBodyResponseSchema, { target: this.target });
     }
@@ -41,6 +46,9 @@ export class CrudSchemaBuilder {
     get jsonFindQuerySchema() {
         return zodToJsonSchema(FindQuerySchema, { target: this.target });
     }
+    get jsonGroupByQuerySchema() {
+        return zodToJsonSchema(GroupByQuerySchema, { target: this.target });
+    }
     get jsonSearchQuerySchema() {
         return zodToJsonSchema(SearchQuerySchema, { target: this.target });
     }
@@ -127,6 +135,22 @@ export class CrudSchemaBuilder {
             }
         };
     }
+    /**
+     * Get JSON schema for find entities
+     */
+    get groupBySchema() {
+        return {
+            ...(this.getTags),
+            query: this.jsonGroupByQuerySchema,
+            response: {
+                200: this.jsonEntityGroupBySchema,
+                400: this.jsonErrorBodyResponse,
+                401: this.jsonErrorBodyResponse,
+                403: this.jsonErrorBodyResponse,
+                500: this.jsonErrorBodyResponse
+            }
+        };
+    }
     /**
      * Get JSON schema for find entities
      */

package/dist/controllers/AbstractFastifyController.js

@@ -332,7 +332,7 @@ class AbstractFastifyController extends CommonController {
             const search = request.query.search;
             const filters = this.parseFilters(request.query.filters);
             this.applyUserAndTenantFilters(filters, request.rbac);
-            //console.log("FILTERS",filters)
+            // console.log("paginate filters",filters)
             let paginateResult = await this.service.paginate({ page, limit, orderBy, order, search, filters });
             return paginateResult;
         }
@@ -382,6 +382,29 @@ class AbstractFastifyController extends CommonController {
             this.handleError(e, reply);
         }
     }
+    async groupBy(request, reply) {
+        try {
+            request.rbac.assertPermission(this.permission.View);
+            const fields = request.query.fields ?
+                request.query.fields.split(',').map(f => f.trim()).filter(f => f.length > 0) :
+                [];
+            const dateFormat = request.query.dateFormat ? request.query.dateFormat : 'day';
+            if (fields.length === 0) {
+                throw new BadRequestError('At least one field is required for grouping');
+            }
+            const filters = this.parseFilters(request.query.filters);
+            this.applyUserAndTenantFilters(filters, request.rbac);
+            const result = await this.service.groupBy({ fields, filters, dateFormat });
+            // console.log("groupby fields",fields)
+            // console.log("groupby dateFormat",dateFormat)
+            // console.log("groupby filters",filters)
+            // console.log("groupby result",result)
+            return result;
+        }
+        catch (e) {
+            this.handleError(e, reply);
+        }
+    }
 }
 export default AbstractFastifyController;
 export { AbstractFastifyController };

package/dist/index.js

@@ -10,6 +10,7 @@ import { PaginateBodyResponseSchema, PaginateQuerySchema } from "./schemas/Pagin
 import { FindQuerySchema } from "./schemas/FindSchema.js";
 import { SearchQuerySchema } from "./schemas/SearchSchema.js";
 import { FindByParamSchema } from "./schemas/FindBySchema.js";
+import { GroupByQuerySchema } from "./schemas/GroupBySchema.js";
 import { ExportBodyResponseSchema } from "./schemas/ExportBodyResponseSchema.js";
 import { ErrorBodyResponseSchema, ValidationErrorBodyResponseSchema } from "./schemas/ErrorBodyResponseSchema.js";
 import { CrudSchemaBuilder } from "./builders/CrudSchemaBuilder.js";
@@ -17,6 +18,6 @@ export {
 //CRUD
 AbstractMongoRepository, AbstractSqliteRepository, AbstractService, AbstractFastifyController, 
 //Schemas
-IdParamSchema, DeleteBodyResponseSchema, PaginateBodyResponseSchema, PaginateQuerySchema, FindQuerySchema, SearchQuerySchema, FindByParamSchema, ErrorBodyResponseSchema, ValidationErrorBodyResponseSchema, ExportBodyResponseSchema, 
+IdParamSchema, DeleteBodyResponseSchema, PaginateBodyResponseSchema, PaginateQuerySchema, FindQuerySchema, GroupByQuerySchema, SearchQuerySchema, FindByParamSchema, ErrorBodyResponseSchema, ValidationErrorBodyResponseSchema, ExportBodyResponseSchema, 
 //Builder
 CrudSchemaBuilder, };

package/dist/repository/AbstractMongoRepository.js

@@ -215,6 +215,151 @@ class AbstractMongoRepository {
         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);
+        // 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 = {};
+        const lookupStages = [];
+        const finalProjectFields = { count: 1, _id: 0 };
+        const refFields = new Set();
+        const dateFields = new Set();
+        // Función para obtener el formato de fecha según el nivel de granularidad
+        const getDateFormat = (field, format) => {
+            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 = [
+            { $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;
 export { AbstractMongoRepository };

package/dist/schemas/GroupBySchema.js

@@ -0,0 +1,7 @@
+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/dist/services/AbstractService.js

@@ -200,6 +200,9 @@ class AbstractService {
             throw e;
         }
     }
+    async groupBy({ fields = [], filters = [], dateFormat = 'day' }) {
+        return await this._repository.groupBy({ fields, filters, dateFormat });
+    }
     async export({ format = 'JSON', headers = [], headersTranslate = [], separator = ';', fileName = 'export', orderBy = '', order = false, search = '', filters = [] }, destinationPath) {
         try {
             let cursor;

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.36.0",
+  "version": "0.37.2",
   "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": "^0.36.0",
-    "@drax/common-share": "^0.36.0",
-    "@drax/identity-share": "^0.36.0",
-    "@drax/media-back": "^0.36.0",
+    "@drax/common-back": "^0.37.2",
+    "@drax/common-share": "^0.37.0",
+    "@drax/identity-share": "^0.37.0",
+    "@drax/media-back": "^0.37.2",
     "@graphql-tools/load-files": "^7.0.0",
     "@graphql-tools/merge": "^9.0.4",
     "mongoose": "^8.6.3",
@@ -33,7 +33,7 @@
     "mongoose-paginate-v2": "^1.8.3"
   },
   "peerDependencies": {
-    "dayjs": "^1.11.13",
+    "dayjs": "^1.11.19",
     "mongoose-paginate-v2": "^1.8.3"
   },
   "devDependencies": {
@@ -45,5 +45,5 @@
     "tsc-alias": "^1.8.10",
     "typescript": "^5.6.2"
   },
-  "gitHead": "096f17a9a7f6e6969b8367a978137e090916f16d"
+  "gitHead": "85833fa79a0d1df3899c13a3a47ed3e7e3fe0448"
 }

package/src/builders/CrudSchemaBuilder.ts

@@ -11,7 +11,8 @@ import {
   FindByParamSchema,
   ErrorBodyResponseSchema,
   ValidationErrorBodyResponseSchema,
-  ExportBodyResponseSchema
+  ExportBodyResponseSchema,
+  GroupByQuerySchema
 } from '../index.js';
 
 export class CrudSchemaBuilder<T extends z.ZodObject<z.ZodRawShape>, TCreate extends z.ZodObject<z.ZodRawShape>, TUpdate extends z.ZodObject<z.ZodRawShape>> {
@@ -54,6 +55,17 @@ export class CrudSchemaBuilder<T extends z.ZodObject<z.ZodRawShape>, TCreate ext
     return zodToJsonSchema(z.array(this.entitySchema), {target: this.target})
   }
 
+  get jsonEntityGroupBySchema() {
+    return zodToJsonSchema(
+      z.array(
+        z.object({
+          count: z.number()
+        }).catchall(z.any())
+      ),
+      {target: this.target}
+    )
+  }
+
   get jsonExportBodyResponse() {
     return zodToJsonSchema(ExportBodyResponseSchema, {target: this.target})
   }
@@ -70,6 +82,10 @@ export class CrudSchemaBuilder<T extends z.ZodObject<z.ZodRawShape>, TCreate ext
     return zodToJsonSchema(FindQuerySchema, {target: this.target})
   }
 
+  get jsonGroupByQuerySchema(){
+    return zodToJsonSchema(GroupByQuerySchema, {target: this.target})
+  }
+
   get jsonSearchQuerySchema(){
     return zodToJsonSchema(SearchQuerySchema, {target: this.target})
   }
@@ -166,6 +182,23 @@ export class CrudSchemaBuilder<T extends z.ZodObject<z.ZodRawShape>, TCreate ext
     }
   }
 
+  /**
+   * Get JSON schema for find entities
+   */
+  get groupBySchema() {
+    return {
+      ...(this.getTags),
+      query: this.jsonGroupByQuerySchema,
+      response: {
+        200: this.jsonEntityGroupBySchema,
+        400: this.jsonErrorBodyResponse,
+        401: this.jsonErrorBodyResponse,
+        403: this.jsonErrorBodyResponse,
+        500: this.jsonErrorBodyResponse
+      }
+    }
+  }
+
   /**
    * Get JSON schema for find entities
    */

package/src/controllers/AbstractFastifyController.ts

@@ -39,6 +39,8 @@ type CustomRequest = FastifyRequest<{
         headersTranslate?: string
         separator?: string
         fileName?: string
+        fields?: string
+        dateFormat?: 'year' | 'month' | 'day' | 'hour' | 'minute' | 'second'
     }
 }>
 
@@ -453,7 +455,7 @@ class AbstractFastifyController<T, C, U> extends CommonController {
             const filters: IDraxFieldFilter[] = this.parseFilters(request.query.filters)
             this.applyUserAndTenantFilters(filters, request.rbac);
 
-            //console.log("FILTERS",filters)
+            // console.log("paginate filters",filters)
 
             let paginateResult = await this.service.paginate({page, limit, orderBy, order, search, filters})
             return paginateResult
@@ -513,6 +515,35 @@ class AbstractFastifyController<T, C, U> extends CommonController {
             this.handleError(e, reply)
         }
     }
+
+    async groupBy(request: CustomRequest, reply: FastifyReply) {
+        try {
+            request.rbac.assertPermission(this.permission.View)
+
+            const fields: string[] = request.query.fields ?
+                request.query.fields.split(',').map(f => f.trim()).filter(f => f.length > 0) :
+                []
+
+            const dateFormat = request.query.dateFormat ? request.query.dateFormat : 'day'
+
+            if (fields.length === 0) {
+                throw new BadRequestError('At least one field is required for grouping')
+            }
+
+            const filters: IDraxFieldFilter[] = this.parseFilters(request.query.filters)
+            this.applyUserAndTenantFilters(filters, request.rbac)
+
+
+            const result = await this.service.groupBy({fields, filters, dateFormat})
+            // console.log("groupby fields",fields)
+            // console.log("groupby dateFormat",dateFormat)
+            // console.log("groupby filters",filters)
+            // console.log("groupby result",result)
+            return result
+        } catch (e) {
+            this.handleError(e, reply)
+        }
+    }
 }
 
 export default AbstractFastifyController;

package/src/index.ts

@@ -12,6 +12,7 @@ import {PaginateBodyResponseSchema, PaginateQuerySchema} from "./schemas/Paginat
 import {FindQuerySchema} from "./schemas/FindSchema.js"
 import {SearchQuerySchema} from "./schemas/SearchSchema.js"
 import {FindByParamSchema} from "./schemas/FindBySchema.js"
+import {GroupByQuerySchema} from "./schemas/GroupBySchema.js"
 import {ExportBodyResponseSchema} from "./schemas/ExportBodyResponseSchema.js"
 import {ErrorBodyResponseSchema, ValidationErrorBodyResponseSchema} from "./schemas/ErrorBodyResponseSchema.js"
 import {CrudSchemaBuilder} from "./builders/CrudSchemaBuilder.js";
@@ -35,6 +36,7 @@ export {
     PaginateBodyResponseSchema,
     PaginateQuerySchema,
     FindQuerySchema,
+    GroupByQuerySchema,
     SearchQuerySchema,
     FindByParamSchema,
     ErrorBodyResponseSchema,