@drax/crud-back 2.9.0 → 3.0.0

package/dist/controllers/AbstractFastifyController.js

@@ -1,4 +1,4 @@
-import { CommonConfig, DraxConfig, LimitError, NotFoundError, BadRequestError, CommonController } from "@drax/common-back";
+import { CommonConfig, DraxConfig, LimitError, NotFoundError, BadRequestError, CommonController, setNestedValue } from "@drax/common-back";
 import { join } from "path";
 import QueryFilterRegex from "../regexs/QueryFilterRegex.js";
 import CrudEventEmitter from "../events/CrudEventEmitter.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 });
                 }
             });
@@ -72,15 +72,26 @@ class AbstractFastifyController extends CommonController {
         }
     }
     assertTenant(item, rbac) {
-        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());
+            }
         }
     }
     assertUser(item, rbac) {
         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());
+            }
         }
     }
     assertUserAndTenant(item, rbac) {
@@ -89,10 +100,10 @@ class AbstractFastifyController extends CommonController {
     }
     applyUserAndTenantSetters(payload, rbac) {
         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);
         }
     }
     extractRequestData(request) {
@@ -212,17 +223,21 @@ class AbstractFastifyController extends CommonController {
             const id = request.params.id;
             const payload = request.body;
             let preItem = await this.service.findById(id);
+            if (!preItem) {
+                reply.statusCode = 404;
+                reply.send({ error: 'NOT_FOUND' });
+            }
             if (!request.rbac.hasSomePermission([this.permission.All, this.permission.UpdateAll])) {
-                if (!preItem) {
-                    reply.statusCode = 404;
-                    reply.send({ error: 'NOT_FOUND' });
-                }
+                //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 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];
             }
@@ -255,17 +270,21 @@ class AbstractFastifyController extends CommonController {
             const id = request.params.id;
             const payload = request.body;
             let preItem = await this.service.findById(id);
+            if (!preItem) {
+                reply.statusCode = 404;
+                reply.send({ error: 'NOT_FOUND' });
+            }
             if (!request.rbac.hasSomePermission([this.permission.All, this.permission.UpdateAll])) {
-                if (!preItem) {
-                    reply.statusCode = 404;
-                    reply.send({ error: 'NOT_FOUND' });
-                }
+                //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];
             }
@@ -404,10 +423,12 @@ class AbstractFastifyController 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) {
@@ -423,8 +444,10 @@ class AbstractFastifyController 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/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

@@ -89,28 +89,32 @@ class AbstractMongoRepository {
             .exec();
         return item;
     }
-    async findByIds(ids) {
+    async findByIds(ids, filters = []) {
         ids.map(id => this.assertId(id));
+        const query = { _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();
         return items;
     }
-    async findOneBy(field, value) {
-        const filter = { [field]: value };
+    async findOneBy(field, value, filters = []) {
+        const query = { [field]: value };
+        MongooseQueryFilter.applyFilters(query, filters, this._model);
         const item = await this._model
-            .findOne(filter)
+            .findOne(query)
             .populate(this._populateFields)
             .lean(this._lean)
             .exec();
         return item;
     }
-    async findBy(field, value, limit = 0) {
-        const filter = { [field]: value };
+    async findBy(field, value, limit = 0, filters = []) {
+        const query = { [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)
@@ -133,7 +137,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 +156,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 +180,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 +198,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 +216,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);
         }
@@ -180,13 +200,19 @@ class AbstractSqliteRepository {
         }
         return items;
     }
-    async search(value, limit = 1000) {
+    async search(value, limit = 1000, filters = []) {
         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);
         }
@@ -199,32 +225,73 @@ class AbstractSqliteRepository {
         await this.decorate(item);
         return item;
     }
-    async findBy(field, value, limit = 0) {
-        const items = this.db.prepare(`SELECT *
-                                       FROM ${this.tableName}
-                                       WHERE ${field} = ? LIMIT ${limit}`).all(value);
+    async findByIds(ids, filters = []) {
+        const inPlaceholders = ids.map(() => '?').join(',');
+        let where = `WHERE ID IN(${inPlaceholders})`;
+        let params = [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);
         for (const item of items) {
             await this.decorate(item);
         }
         return items;
     }
-    async findOneBy(field, value) {
-        const item = this.db.prepare(`SELECT *
-                                      FROM ${this.tableName}
-                                      WHERE ${field} = ?`).get(value);
+    async findBy(field, value, limit = 0, filters = []) {
+        let where = `WHERE ${field} = ?`;
+        let params = [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]);
+        for (const item of items) {
+            await this.decorate(item);
+        }
+        return items;
+    }
+    async findOneBy(field, value, filters = []) {
+        let where = `WHERE ${field} = ?`;
+        let params = [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);
         await this.decorate(item);
         return item;
     }
     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 +301,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 +319,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/dist/services/AbstractService.js

@@ -110,9 +110,12 @@ class AbstractService {
     }
     async updatePartial(id, data) {
         data = await this.validateInputUpdatePartial(data);
+        if (this.transformUpdatePartial) {
+            data = await this.transformUpdatePartial(data);
+        }
         let item = await this._repository.updatePartial(id, data);
-        if (this.onUpdated) {
-            await this.onUpdated(item);
+        if (this.onUpdatedPartial) {
+            await this.onUpdatedPartial(item);
         }
         item = await this.validateOutput(item);
         return item;
@@ -155,9 +158,9 @@ class AbstractService {
             throw e;
         }
     }
-    async findOneBy(field, value) {
+    async findOneBy(field, value, filters = []) {
         try {
-            let item = await this._repository.findOneBy(field, value);
+            let item = await this._repository.findOneBy(field, value, filters);
             if (item && this.transformRead) {
                 item = await this.transformRead(item);
             }
@@ -211,9 +214,9 @@ class AbstractService {
             throw e;
         }
     }
-    async findBy(field, value, limit = 1000) {
+    async findBy(field, value, limit = 1000, filters = []) {
         try {
-            let items = await this._repository.findBy(field, value, limit);
+            let items = await this._repository.findBy(field, value, limit, filters);
             if (this.transformRead) {
                 items = await Promise.all(items.map(item => this.transformRead(item)));
             }

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "2.9.0",
+  "version": "3.0.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-share": "^2.0.0",
-    "@drax/identity-share": "^2.0.0",
-    "@drax/media-back": "^2.9.0",
+    "@drax/common-back": "^3.0.0",
+    "@drax/common-share": "^3.0.0",
+    "@drax/identity-share": "^3.0.0",
+    "@drax/media-back": "^3.0.0",
     "@graphql-tools/load-files": "^7.0.0",
     "@graphql-tools/merge": "^9.0.4",
     "mongoose": "^8.23.0",
@@ -44,7 +44,8 @@
     "nodemon": "^3.1.0",
     "ts-node": "^10.9.2",
     "tsc-alias": "^1.8.10",
-    "typescript": "^5.9.3"
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.4"
   },
-  "gitHead": "2bc9b59a45c762bd32403dce14db2693be34dcc7"
+  "gitHead": "63ae718b24ea25ae80b1a9a5dfb84a3abbb95199"
 }