@drax/audit-back 0.38.0 → 0.39.0

package/dist/models/AuditModel.js

@@ -3,6 +3,7 @@ import uniqueValidator from 'mongoose-unique-validator';
 import mongoosePaginate from 'mongoose-paginate-v2';
 const AuditSchema = new mongoose.Schema({
     entity: { type: String, required: true, index: true, unique: false },
+    resourceId: { type: String, required: false, index: true, unique: false },
     user: {
         id: { type: String, required: true, index: true, unique: false },
         username: { type: String, required: true, index: false, unique: false },
@@ -13,15 +14,19 @@ const AuditSchema = new mongoose.Schema({
     userAgent: { type: String, required: false, index: false, unique: false },
     changes: [{
             field: { type: String, required: true, index: false, unique: false },
-            old: { type: String, required: false, index: false, unique: false },
-            new: { type: String, required: false, index: false, unique: false }
+            old: { type: mongoose.Schema.Types.Mixed, required: false, index: false, unique: false },
+            new: { type: mongoose.Schema.Types.Mixed, required: false, index: false, unique: false }
         }],
     sessionId: { type: String, required: false, index: true, unique: false },
     requestId: { type: String, required: false, index: true, unique: false },
     detail: { type: String, required: false, index: false, unique: false },
     tenant: {
         id: { type: String, required: false, index: true, unique: false },
-        name: { type: String, required: false, index: false, unique: false }
+        name: { type: String, required: false, index: true, unique: false }
+    },
+    apiKey: {
+        id: { type: String, required: false, index: true, unique: false },
+        name: { type: String, required: false, index: true, unique: false }
     }
 }, { timestamps: true });
 AuditSchema.plugin(uniqueValidator, { message: 'validation.unique' });

package/dist/schemas/AuditSchema.js

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 const AuditBaseSchema = z.object({
     entity: z.string().min(1, 'validation.required'),
+    resourceId: z.string().optional().nullable(),
     user: z.object({
         id: z.string().min(1, 'validation.required'),
         username: z.string().min(1, 'validation.required'),
@@ -11,8 +12,8 @@ const AuditBaseSchema = z.object({
     userAgent: z.string().optional().nullable(),
     changes: z.array(z.object({
         field: z.string().min(1, 'validation.required'),
-        old: z.string().optional().nullable(),
-        new: z.string().optional().nullable()
+        old: z.any().optional().nullable(),
+        new: z.any().optional().nullable()
     })).optional(),
     sessionId: z.string().optional().nullable(),
     requestId: z.string().optional().nullable(),
@@ -20,6 +21,10 @@ const AuditBaseSchema = z.object({
     tenant: z.object({
         id: z.string().optional().nullable(),
         name: z.string().optional().nullable()
+    }).optional().nullable(),
+    apiKey: z.object({
+        id: z.string().optional().nullable(),
+        name: z.string().optional().nullable()
     }).optional().nullable()
 });
 const AuditSchema = AuditBaseSchema

package/dist/utils/RegisterCrudEvent.js

@@ -6,11 +6,12 @@ async function RegisterCrudEvent(crudEventData) {
         if (!preItem) {
             return changes;
         }
+        const ignoredFields = ['_id', 'createdAt', 'updatedAt', 'createdBy', '$__', '$isNew'];
         // Si no hay postItem (eliminación), registrar todos los campos como eliminados
         if (!postItem) {
             Object.keys(preItem).forEach(key => {
                 // Ignorar campos internos de MongoDB y timestamps
-                if (!key.startsWith('_') && key !== 'createdAt' && key !== 'updatedAt') {
+                if (!key.startsWith('_') && !ignoredFields.includes(key)) {
                     changes.push({
                         field: key,
                         old: preItem[key],
@@ -20,17 +21,49 @@ async function RegisterCrudEvent(crudEventData) {
             });
             return changes;
         }
+        // Función para comparar valores teniendo en cuenta ObjectId y populated
+        function areValuesEqual(oldValue, newValue) {
+            // Si son exactamente iguales
+            if (JSON.stringify(oldValue) === JSON.stringify(newValue)) {
+                return true;
+            }
+            // Comparar referencias (ObjectId vs objeto poblado)
+            const oldId = extractId(oldValue);
+            const newId = extractId(newValue);
+            if (oldId && newId) {
+                return oldId.toString() === newId.toString();
+            }
+            // Si uno es array y el otro también, comparar elementos
+            if (Array.isArray(oldValue) && Array.isArray(newValue)) {
+                if (oldValue.length !== newValue.length) {
+                    return false;
+                }
+                return oldValue.every((item, index) => areValuesEqual(item, newValue[index]));
+            }
+            return false;
+        }
+        function extractId(value) {
+            // Si es un ObjectId directo
+            if (value && typeof value === 'object' && value._id) {
+                return value._id;
+            }
+            // Si es directamente un ObjectId
+            if (value && typeof value === 'object' && value.toString && value.constructor.name === 'ObjectId') {
+                return value;
+            }
+            return null;
+        }
         // Obtener todas las claves únicas de ambos objetos
         const allKeys = new Set([...Object.keys(preItem), ...Object.keys(postItem)]);
         allKeys.forEach(key => {
             // Ignorar campos internos de MongoDB y timestamps
-            if (key.startsWith('_') || key === 'createdAt' || key === 'updatedAt') {
+            if (key.startsWith('_') || ignoredFields.includes(key)) {
                 return;
             }
             const oldValue = preItem[key];
             const newValue = postItem[key];
-            // Comparar valores
-            if (JSON.stringify(oldValue) !== JSON.stringify(newValue)) {
+            // Comparar valores usando la nueva función
+            if (!areValuesEqual(oldValue, newValue)) {
                 changes.push({
                     field: key,
                     old: oldValue,
@@ -43,23 +76,28 @@ async function RegisterCrudEvent(crudEventData) {
     let changes = diff(crudEventData.preItem, crudEventData.postItem);
     let data = {
         action: crudEventData.action,
+        resourceId: crudEventData.resourceId || crudEventData.postItem?._id?.toString() || crudEventData.preItem?._id?.toString(),
         changes: changes,
         createdAt: crudEventData.timestamp,
-        detail: "",
+        detail: crudEventData.detail,
         entity: crudEventData.entity,
         tenant: {
-            id: crudEventData.user.tenant.id,
-            name: crudEventData.user.tenant.name
+            id: crudEventData.user?.tenant?.id,
+            name: crudEventData.user?.tenant?.name
         },
         user: {
             id: crudEventData.user.id,
             username: crudEventData.user.username,
-            rolName: crudEventData.user.role.name,
+            rolName: crudEventData.user.role?.name,
+        },
+        apiKey: {
+            id: crudEventData.user?.apiKey?.id,
+            name: crudEventData.user?.apiKey?.name
         },
         ip: crudEventData.ip,
         userAgent: crudEventData.userAgent,
         sessionId: crudEventData.user.session,
-        requestId: crudEventData.requestId
+        requestId: crudEventData.requestId,
     };
     return await AuditServiceFactory.instance.create(data);
 }

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.38.0",
+  "version": "0.39.0",
   "description": "Audit backend",
   "main": "dist/index.js",
   "types": "types/index.d.ts",
@@ -22,8 +22,8 @@
   "author": "Cristian Incarnato & Drax Team",
   "license": "ISC",
   "dependencies": {
-    "@drax/crud-back": "^0.38.0",
-    "@drax/crud-share": "^0.38.0",
+    "@drax/crud-back": "^0.39.0",
+    "@drax/crud-share": "^0.39.0",
     "mongoose": "^8.6.3",
     "mongoose-paginate-v2": "^1.8.3"
   },
@@ -39,5 +39,5 @@
     "tsc-alias": "^1.8.10",
     "typescript": "^5.6.2"
   },
-  "gitHead": "43c90f3c12165e7527edefbc80dd327a59236dd5"
+  "gitHead": "b019c40f954cf60e4ff61c53e27d5bafaea6f16c"
 }

package/src/models/AuditModel.ts

@@ -6,6 +6,7 @@ import type {IAudit} from '@drax/audit-share'
 
 const AuditSchema = new mongoose.Schema<IAudit>({
     entity: {type: String, required: true, index: true, unique: false},
+    resourceId: {type: String, required: false, index: true, unique: false},
     user: {
         id: {type: String, required: true, index: true, unique: false},
         username: {type: String, required: true, index: false, unique: false},
@@ -16,15 +17,19 @@ const AuditSchema = new mongoose.Schema<IAudit>({
     userAgent: {type: String, required: false, index: false, unique: false},
     changes: [{
         field: {type: String, required: true, index: false, unique: false},
-        old: {type: String, required: false, index: false, unique: false},
-        new: {type: String, required: false, index: false, unique: false}
+        old: {type: mongoose.Schema.Types.Mixed, required: false, index: false, unique: false},
+        new: {type: mongoose.Schema.Types.Mixed, required: false, index: false, unique: false}
     }],
     sessionId: {type: String, required: false, index: true, unique: false},
     requestId: {type: String, required: false, index: true, unique: false},
     detail: {type: String, required: false, index: false, unique: false},
     tenant: {
         id: {type: String, required: false, index: true, unique: false},
-        name: {type: String, required: false, index: false, unique: false}
+        name: {type: String, required: false, index: true, unique: false}
+    },
+    apiKey: {
+        id: {type: String, required: false, index: true, unique: false},
+        name: {type: String, required: false, index: true, unique: false}
     }
 }, {timestamps: true});
 

package/src/schemas/AuditSchema.ts

@@ -3,6 +3,7 @@ import {z} from 'zod';
 
 const AuditBaseSchema = z.object({
     entity: z.string().min(1, 'validation.required'),
+    resourceId: z.string().optional().nullable(),
     user: z.object({
         id: z.string().min(1, 'validation.required'),
         username: z.string().min(1, 'validation.required'),
@@ -14,8 +15,8 @@ const AuditBaseSchema = z.object({
     changes: z.array(
         z.object({
             field: z.string().min(1, 'validation.required'),
-            old: z.string().optional().nullable(),
-            new: z.string().optional().nullable()
+            old: z.any().optional().nullable(),
+            new: z.any().optional().nullable()
         })
     ).optional(),
     sessionId: z.string().optional().nullable(),
@@ -24,6 +25,10 @@ const AuditBaseSchema = z.object({
     tenant: z.object({
         id: z.string().optional().nullable(),
         name: z.string().optional().nullable()
+    }).optional().nullable(),
+    apiKey: z.object({
+        id: z.string().optional().nullable(),
+        name: z.string().optional().nullable()
     }).optional().nullable()
 });
 

package/src/utils/RegisterCrudEvent.ts

@@ -18,11 +18,13 @@ async function RegisterCrudEvent(crudEventData: IDraxCrudEvent){
             return changes;
         }
 
+        const ignoredFields = ['_id', 'createdAt', 'updatedAt', 'createdBy','$__','$isNew'];
+
         // Si no hay postItem (eliminación), registrar todos los campos como eliminados
         if (!postItem) {
             Object.keys(preItem).forEach(key => {
                 // Ignorar campos internos de MongoDB y timestamps
-                if (!key.startsWith('_') && key !== 'createdAt' && key !== 'updatedAt') {
+                if (!key.startsWith('_') && !ignoredFields.includes(key)) {
                     changes.push({
                         field: key,
                         old: preItem[key],
@@ -33,20 +35,60 @@ async function RegisterCrudEvent(crudEventData: IDraxCrudEvent){
             return changes;
         }
 
+        // Función para comparar valores teniendo en cuenta ObjectId y populated
+        function areValuesEqual(oldValue: any, newValue: any): boolean {
+            // Si son exactamente iguales
+            if (JSON.stringify(oldValue) === JSON.stringify(newValue)) {
+                return true;
+            }
+
+            // Comparar referencias (ObjectId vs objeto poblado)
+            const oldId = extractId(oldValue);
+            const newId = extractId(newValue);
+
+            if (oldId && newId) {
+                return oldId.toString() === newId.toString();
+            }
+
+            // Si uno es array y el otro también, comparar elementos
+            if (Array.isArray(oldValue) && Array.isArray(newValue)) {
+                if (oldValue.length !== newValue.length) {
+                    return false;
+                }
+                return oldValue.every((item, index) => 
+                    areValuesEqual(item, newValue[index])
+                );
+            }
+
+            return false;
+        }
+
+        function extractId(value: any): any {
+            // Si es un ObjectId directo
+            if (value && typeof value === 'object' && value._id) {
+                return value._id;
+            }
+            // Si es directamente un ObjectId
+            if (value && typeof value === 'object' && value.toString && value.constructor.name === 'ObjectId') {
+                return value;
+            }
+            return null;
+        }
+
         // Obtener todas las claves únicas de ambos objetos
         const allKeys = new Set([...Object.keys(preItem), ...Object.keys(postItem)]);
 
         allKeys.forEach(key => {
             // Ignorar campos internos de MongoDB y timestamps
-            if (key.startsWith('_') || key === 'createdAt' || key === 'updatedAt') {
+            if (key.startsWith('_') || ignoredFields.includes(key)) {
                 return;
             }
 
             const oldValue = preItem[key];
             const newValue = postItem[key];
 
-            // Comparar valores
-            if (JSON.stringify(oldValue) !== JSON.stringify(newValue)) {
+            // Comparar valores usando la nueva función
+            if (!areValuesEqual(oldValue, newValue)) {
                 changes.push({
                     field: key,
                     old: oldValue,
@@ -62,23 +104,28 @@ async function RegisterCrudEvent(crudEventData: IDraxCrudEvent){
 
     let data: IAuditBase = {
         action: crudEventData.action,
+        resourceId: crudEventData.resourceId || crudEventData.postItem?._id?.toString() || crudEventData.preItem?._id?.toString(),
         changes: changes,
         createdAt: crudEventData.timestamp,
-        detail: "",
+        detail: crudEventData.detail,
         entity: crudEventData.entity,
         tenant: {
-            id: crudEventData.user.tenant.id,
-            name: crudEventData.user.tenant.name
+            id: crudEventData.user?.tenant?.id,
+            name: crudEventData.user?.tenant?.name
         },
         user: {
             id: crudEventData.user.id,
             username: crudEventData.user.username,
-            rolName: crudEventData.user.role.name,
+            rolName: crudEventData.user.role?.name,
+        },
+        apiKey: {
+            id: crudEventData.user?.apiKey?.id,
+            name: crudEventData.user?.apiKey?.name
         },
         ip: crudEventData.ip,
         userAgent: crudEventData.userAgent,
         sessionId: crudEventData.user.session,
-        requestId: crudEventData.requestId
+        requestId: crudEventData.requestId,
     }
 
     return await AuditServiceFactory.instance.create(data)