@drax/crud-back 2.9.0 → 3.0.0

package/src/controllers/AbstractFastifyController.ts

@@ -5,7 +5,7 @@ import {
     LimitError,
     NotFoundError,
     BadRequestError,
-    CommonController
+    CommonController, setNestedValue
 } from "@drax/common-back";
 import {IRbac} from "@drax/identity-share";
 import type {FastifyReply, FastifyRequest} from "fastify";
@@ -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})
                 }
 
@@ -150,17 +150,28 @@ class AbstractFastifyController<T, C, U> extends CommonController {
     }
 
     protected assertTenant(item: T, rbac: IRbac) {
-        if (this.tenantAssert) {
-            const itemTenantId = item[this.tenantField]?._id ? item[this.tenantField]._id.toString() : null
-            rbac.assertTenantId(itemTenantId)
+
+        //Si tenantAssert esta habilitado y si ademas el usuario pertenece a un tenant
+        if (this.tenantAssert && rbac.hasTenant) {
+
+            //Si esta populado
+            if(item[this.tenantField]?._id){
+                rbac.assertTenantId(item[this.tenantField]._id.toString())//
+            //Si esta crudo
+            }else if(item[this.tenantField]){
+                rbac.assertTenantId(item[this.tenantField].toString())
+            }
         }
     }
 
     protected assertUser(item: T, rbac: IRbac) {
 
         if (this.userAssert) {
-            const itemUserId = item[this.userField]?._id ? item[this.userField]._id.toString() : null
-            rbac.assertUserId(itemUserId)
+            if(item[this.userField]?._id){
+                rbac.assertUserId(item[this.userField]._id.toString())
+            }else if(item[this.userField]){
+                rbac.assertUserId(item[this.userField].toString())
+            }
         }
     }
 
@@ -170,12 +181,13 @@ class AbstractFastifyController<T, C, U> extends CommonController {
     }
 
     protected applyUserAndTenantSetters(payload: any, rbac: any) {
+
         if (this.tenantSetter && rbac.tenantId) {
-            payload[this.tenantField] = rbac.tenantId
+            setNestedValue(payload, this.tenantField, rbac.tenantId)
         }
 
         if (this.userSetter && rbac.userId) {
-            payload[this.userField] = rbac.userId
+            setNestedValue(payload, this.userField, rbac.userId)
         }
     }
 
@@ -309,21 +321,24 @@ class AbstractFastifyController<T, C, U> extends CommonController {
 
             let preItem = await this.service.findById(id)
 
-            if (!request.rbac.hasSomePermission([this.permission.All, this.permission.UpdateAll])) {
-
-                if (!preItem) {
-                    reply.statusCode = 404
-                    reply.send({error: 'NOT_FOUND'})
-                }
+            if (!preItem) {
+                reply.statusCode = 404
+                reply.send({error: 'NOT_FOUND'})
+            }
 
+            if (!request.rbac.hasSomePermission([this.permission.All, this.permission.UpdateAll])) {
+                //Si assertUser habilitado y si el usuario no tiene UpdateAll/All, solo puede modificar sus propios registros
                 this.assertUser(preItem, request.rbac)
             }
+            //Si assertTenant habilitado y si usuario tiene tenant, solo puede modificar registros de su tenant
+            this.assertTenant(preItem, request.rbac)
 
-            //Definido el tenant/user en el create no debe modificarse en un update
+            //Definido el tenant en create no debe modificarse en un update
             if(this.tenantSetter) {
                 delete payload[this.tenantField]
             }
 
+            //Definido el user en create no debe modificarse en un update
             if(this.userSetter){
                 delete payload[this.userField]
             }
@@ -365,21 +380,25 @@ class AbstractFastifyController<T, C, U> extends CommonController {
 
             let preItem = await this.service.findById(id)
 
-            if (!request.rbac.hasSomePermission([this.permission.All, this.permission.UpdateAll])) {
-
-                if (!preItem) {
-                    reply.statusCode = 404
-                    reply.send({error: 'NOT_FOUND'})
-                }
+            if (!preItem) {
+                reply.statusCode = 404
+                reply.send({error: 'NOT_FOUND'})
+            }
 
+            if (!request.rbac.hasSomePermission([this.permission.All, this.permission.UpdateAll])) {
+                //Si assertUser habilitado y si el usuario no tiene UpdateAll/All, solo puede modificar sus propios registros
                 this.assertUser(preItem, request.rbac)
             }
 
-            //Definido el tenant/user en el create no debe modificarse en un update
+            //Si assertTenant habilitado y si usuario tiene tenant, solo puede modificar registros de su tenant
+            this.assertTenant(preItem, request.rbac)
+
+            //Definido el tenant en el create no debe modificarse en un update
             if(this.tenantSetter) {
                 delete payload[this.tenantField]
             }
 
+            //Definido el user en el create no debe modificarse en un update
             if(this.userSetter){
                 delete payload[this.userField]
             }
@@ -552,11 +571,15 @@ class AbstractFastifyController<T, C, U> extends CommonController {
             const limit = this.defaultLimit
             const field = request.params.field
             const value = request.params.value
-            let items = await this.service.findBy(field, value, limit)
 
-            for (let item of items) {
-                this.assertUserAndTenant(item, request.rbac)
-            }
+            let filters = []
+            this.applyUserAndTenantFilters(filters, request.rbac);
+
+            let items = await this.service.findBy(field, value, limit, filters)
+
+            // for (let item of items) {
+            //     this.assertUserAndTenant(item, request.rbac)
+            // }
 
             return items
         } catch (e) {
@@ -574,8 +597,13 @@ class AbstractFastifyController<T, C, U> extends CommonController {
 
             const field = request.params.field
             const value = request.params.value
-            let item = await this.service.findOneBy(field, value)
-            this.assertUserAndTenant(item, request.rbac);
+
+            let filters = []
+            this.applyUserAndTenantFilters(filters, request.rbac);
+
+            let item = await this.service.findOneBy(field, value, filters)
+
+            // this.assertUserAndTenant(item, request.rbac);
 
             return item
         } catch (e) {

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

@@ -122,12 +122,16 @@ class AbstractMongoRepository<T, C, U> implements IDraxCrud<T, C, U> {
         return item as T;
     }
 
-    async findByIds(ids: Array<string>): Promise<T[]> {
+    async findByIds(ids: Array<string>, filters: IDraxFieldFilter[] = []): Promise<T[]> {
 
         ids.map(id => this.assertId(id))
 
+        const query: any = {_id: {$in: ids}}
+
+        MongooseQueryFilter.applyFilters(query, filters, this._model)
+
         const items = await this._model
-            .find({_id: {$in: ids}})
+            .find(query)
             .populate(this._populateFields)
             .lean(this._lean)
             .exec()
@@ -136,11 +140,13 @@ class AbstractMongoRepository<T, C, U> implements IDraxCrud<T, C, U> {
         return items as T[]
     }
 
-    async findOneBy(field: string, value: any): Promise<T | null> {
-        const filter: any = {[field]: value}
+    async findOneBy(field: string, value: any, filters: IDraxFieldFilter[] = []): Promise<T | null> {
+        const query: any = {[field]: value}
+
+        MongooseQueryFilter.applyFilters(query, filters, this._model)
 
         const item = await this._model
-            .findOne(filter)
+            .findOne(query)
             .populate(this._populateFields)
             .lean(this._lean)
             .exec()
@@ -149,10 +155,13 @@ 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[]> {
-        const filter: any = {[field]: value}
+    async findBy(field: string, value: any, limit: number = 0, filters: IDraxFieldFilter[] = []): Promise<T[]> {
+        const query: any = {[field]: value}
+
+        MongooseQueryFilter.applyFilters(query, filters, this._model)
+
         const items = await this._model
-            .find(filter)
+            .find(query)
             .limit(limit)
             .populate(this._populateFields)
             .lean(this._lean)
@@ -184,7 +193,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 +226,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 +258,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 +287,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 +318,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 +329,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

package/src/repository/AbstractSqliteRepository.ts

@@ -1,6 +1,6 @@
 import sqlite from "better-sqlite3";
 import type {
-    IDraxCrud,
+    IDraxCrud, IDraxFieldFilter,
     IDraxFindOptions,
     IDraxGroupByOptions,
     IDraxPaginateOptions,
@@ -8,10 +8,13 @@ import type {
 } from "@drax/crud-share";
 import {randomUUID} from "node:crypto";
 import {
-    SqlSort, SqlQueryFilter, SqliteTableBuilder, SqliteTableField,
-    SqliteErrorToValidationError, MongooseQueryFilter
+    SqlSort,
+    SqlQueryFilter,
+    SqliteTableBuilder,
+    SqliteTableField,
+    SqliteErrorToValidationError
 } from "@drax/common-back";
-import mongoose from "mongoose";
+
 
 
 class AbstractSqliteRepository<T, C, U> implements IDraxCrud<T, C, U> {
@@ -195,31 +198,50 @@ class AbstractSqliteRepository<T, C, U> implements IDraxCrud<T, C, U> {
         const offset = page > 1 ? (page - 1) * limit : 0
 
         let where = ""
+        let params: any[] = []
+
+        // 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]) as T[];
+        // 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]) as T[]
 
         for (const item of items) {
             await this.decorate(item)
         }
 
         return {
-            page: page,
-            limit: limit,
+            page,
+            limit,
             total: rCount.count,
-            items: items
+            items
         }
     }
 
@@ -229,24 +251,37 @@ class AbstractSqliteRepository<T, C, U> implements IDraxCrud<T, C, U> {
                    order = 'desc',
                    search = '',
                    filters = []
-               }: IDraxFindOptions): Promise<any[]> {
-
+               }: IDraxFindOptions): Promise<T[]> {
 
         let where = ""
+        let params: any[] = []
+
+        // 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]) as T[];
+        const items = this.db
+            .prepare(`SELECT * FROM ${this.tableName} ${where} ${sort} LIMIT ?`)
+            .all([...params, limit]) as T[]
 
         for (const item of items) {
             await this.decorate(item)
@@ -264,13 +299,25 @@ class AbstractSqliteRepository<T, C, U> implements IDraxCrud<T, C, U> {
         return items
     }
 
-    async search(value: any, limit: number = 1000): Promise<any[]> {
+    async search(value: any, limit: number = 1000, filters: IDraxFieldFilter[] = []): Promise<T[]> {
+
         let where = ""
+        let params: any[] = []
+
         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]) as T[]
 
         for (const item of items) {
             await this.decorate(item)
@@ -287,22 +334,73 @@ class AbstractSqliteRepository<T, C, U> implements IDraxCrud<T, C, U> {
         return item
     }
 
-    async findBy(field: string, value: any, limit: number = 0): Promise<T[] | null> {
-        const items = this.db.prepare(`SELECT *
-                                       FROM ${this.tableName}
-                                       WHERE ${field} = ? LIMIT ${limit}`).all(value);
+    async findByIds(ids: string[], filters: IDraxFieldFilter[] = []): Promise<T[] | null> {
+
+        const inPlaceholders = ids.map(() => '?').join(',')
+
+        let where = `WHERE ID IN(${inPlaceholders})`
+        let params: any[] = [ids]
+
+        if (filters.length > 0) {
+            const result = SqlQueryFilter.applyFilters(where, filters)
+            where = result.where
+            params.push(...result.params)
+        }
+
+        const items = this.db
+            .prepare(`SELECT * FROM ${this.tableName} ${where}`)
+            .all(params) as T[]
+
         for (const item of items) {
             await this.decorate(item)
         }
+
         return items
+
     }
 
-    async findOneBy(field: string, value: any): Promise<T | null> {
-        const item = this.db.prepare(`SELECT *
-                                      FROM ${this.tableName}
-                                      WHERE ${field} = ?`).get(value);
+    async findBy(field: string, value: any, limit: number = 0, filters: IDraxFieldFilter[] = []): Promise<T[] | null> {
+
+        let where = `WHERE ${field} = ?`
+        let params: any[] = [value]
+
+        if (filters.length > 0) {
+            const result = SqlQueryFilter.applyFilters(where, filters)
+            where = result.where
+            params.push(...result.params)
+        }
+
+        const items = this.db
+            .prepare(`SELECT * FROM ${this.tableName} ${where}  LIMIT ?`)
+            .all([...params, limit]) as T[]
+
+        for (const item of items) {
+            await this.decorate(item)
+        }
+
+        return items
+
+    }
+
+    async findOneBy(field: string, value: any, filters: IDraxFieldFilter[] = []): Promise<T | null> {
+
+        let where = `WHERE ${field} = ?`
+        let params: any[] = [value]
+
+        if (filters.length > 0) {
+            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(params) as T
+
         await this.decorate(item)
+
         return item
+
     }
 
     async findOne({
@@ -311,17 +409,32 @@ class AbstractSqliteRepository<T, C, U> implements IDraxCrud<T, C, U> {
                   }: IDraxFindOptions): Promise<T> {
 
         let where = ""
+        let params: any[] = []
 
+        // 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)
@@ -331,17 +444,20 @@ class AbstractSqliteRepository<T, C, U> implements IDraxCrud<T, C, U> {
     }
 
     async groupBy({fields = [], filters = [], dateFormat = 'day'}: IDraxGroupByOptions): Promise<Array<any>> {
+
         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: any[] = []
+
         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: string, format: string): string => {
             const formats: { [key: string]: string } = {
                 'year': `strftime('%Y', ${field})`,
@@ -354,46 +470,68 @@ class AbstractSqliteRepository<T, C, U> implements IDraxCrud<T, C, U> {
             return formats[format] || formats['day']
         }
 
-        // Determinar si cada campo es de fecha
         const isDateField = (field: string): boolean => {
             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: string): boolean => {
+            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: string[] = []
+        const groupParts: string[] = []
+
+        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() as Array<any>
 
-            // 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) as Array<any>
+
+            // for (const item of result) {
+            //     await this.decorate(item)
+            // }
 
             return result
+
         } catch (e) {
             console.error("GroupBy query error:", e)
             throw e