@drax/crud-back 2.9.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

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.9.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.9.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": "2bc9b59a45c762bd32403dce14db2693be34dcc7"
+  "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