@drax/audit-back 0.38.0

package/dist/controllers/AuditController.js

@@ -0,0 +1,54 @@
+import AuditServiceFactory from "../factory/services/AuditServiceFactory.js";
+import { AbstractFastifyController } from "@drax/crud-back";
+import AuditPermissions from "../permissions/AuditPermissions.js";
+import { MethodNotAllowedError } from "@drax/common-back";
+class AuditController extends AbstractFastifyController {
+    constructor() {
+        super(AuditServiceFactory.instance, AuditPermissions);
+        this.tenantField = "tenant.id";
+        this.userField = "user";
+        this.tenantFilter = true;
+        this.userFilter = false;
+        this.tenantSetter = false;
+        this.userSetter = false;
+        this.tenantAssert = false;
+        this.userAssert = false;
+    }
+    async create(request, reply) {
+        try {
+            throw new MethodNotAllowedError();
+        }
+        catch (e) {
+            this.handleError(e, reply);
+        }
+        return null;
+    }
+    async update(request, reply) {
+        try {
+            throw new MethodNotAllowedError();
+        }
+        catch (e) {
+            this.handleError(e, reply);
+        }
+        return null;
+    }
+    async updatePartial(request, reply) {
+        try {
+            throw new MethodNotAllowedError();
+        }
+        catch (e) {
+            this.handleError(e, reply);
+        }
+        return null;
+    }
+    async delete(request, reply) {
+        try {
+            throw new MethodNotAllowedError();
+        }
+        catch (e) {
+            this.handleError(e, reply);
+        }
+    }
+}
+export default AuditController;
+export { AuditController };

package/dist/factory/services/AuditServiceFactory.js

@@ -0,0 +1,15 @@
+import AuditRepository from '../../repository/AuditRepository.js';
+import { AuditService } from '../../services/AuditService.js';
+import { AuditBaseSchema } from "../../schemas/AuditSchema.js";
+class AuditServiceFactory {
+    static get instance() {
+        if (!AuditServiceFactory.service) {
+            const repository = new AuditRepository();
+            const schema = AuditBaseSchema;
+            AuditServiceFactory.service = new AuditService(repository, schema);
+        }
+        return AuditServiceFactory.service;
+    }
+}
+export default AuditServiceFactory;
+export { AuditServiceFactory };

package/dist/index.js

@@ -0,0 +1,10 @@
+import AuditPermissions from './permissions/AuditPermissions.js';
+import AuditSchema from './schemas/AuditSchema.js';
+import AuditModel from './models/AuditModel.js';
+import AuditRepository from './repository/AuditRepository.js';
+import AuditService from './services/AuditService.js';
+import AuditServiceFactory from './factory/services/AuditServiceFactory.js';
+import AuditController from './controllers/AuditController.js';
+import AuditRoutes from './routes/AuditRoutes.js';
+import { RegisterCrudEvent } from './utils/RegisterCrudEvent.js';
+export { AuditPermissions, AuditSchema, AuditModel, AuditRepository, AuditService, AuditServiceFactory, AuditController, AuditRoutes, RegisterCrudEvent };

package/dist/interfaces/IAuditRepository.js

@@ -0,0 +1 @@
+export {};

package/dist/models/AuditModel.js

@@ -0,0 +1,38 @@
+import { mongoose } from '@drax/common-back';
+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 },
+    user: {
+        id: { type: String, required: true, index: true, unique: false },
+        username: { type: String, required: true, index: false, unique: false },
+        rolName: { type: String, required: false, index: false, unique: false }
+    },
+    action: { type: String, required: true, index: true, unique: false },
+    ip: { type: String, required: false, index: false, unique: false },
+    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 }
+        }],
+    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 }
+    }
+}, { timestamps: true });
+AuditSchema.plugin(uniqueValidator, { message: 'validation.unique' });
+AuditSchema.plugin(mongoosePaginate);
+AuditSchema.virtual("id").get(function () {
+    return this._id.toString();
+});
+AuditSchema.set('toJSON', { getters: true, virtuals: true });
+AuditSchema.set('toObject', { getters: true, virtuals: true });
+const MODEL_NAME = 'Audit';
+const COLLECTION_NAME = 'Audit';
+const AuditModel = mongoose.model(MODEL_NAME, AuditSchema, COLLECTION_NAME);
+export { AuditSchema, AuditModel };
+export default AuditModel;

package/dist/permissions/AuditPermissions.js

@@ -0,0 +1,8 @@
+var AuditPermissions;
+(function (AuditPermissions) {
+    AuditPermissions["View"] = "audit:view";
+    AuditPermissions["ViewAll"] = "audit:viewAll";
+    AuditPermissions["Manage"] = "audit:manage";
+})(AuditPermissions || (AuditPermissions = {}));
+export { AuditPermissions };
+export default AuditPermissions;

package/dist/repository/AuditRepository.js

@@ -0,0 +1,12 @@
+import { AbstractMongoRepository } from "@drax/crud-back";
+import { AuditModel } from "../models/AuditModel.js";
+class AuditMongoRepository extends AbstractMongoRepository {
+    constructor() {
+        super();
+        this._model = AuditModel;
+        this._searchFields = ['entity', 'action', 'sessionId', 'requestId'];
+        this._populateFields = [];
+    }
+}
+export default AuditMongoRepository;
+export { AuditMongoRepository };

package/dist/routes/AuditRoutes.js

@@ -0,0 +1,15 @@
+import AuditController from "../controllers/AuditController.js";
+import { CrudSchemaBuilder } from "@drax/crud-back";
+import { AuditSchema, AuditBaseSchema } from '../schemas/AuditSchema.js';
+async function AuditFastifyRoutes(fastify, options) {
+    const controller = new AuditController();
+    const schemas = new CrudSchemaBuilder(AuditSchema, AuditBaseSchema, AuditBaseSchema, 'Audit', 'openApi3', ['Audit']);
+    fastify.get('/api/audits', { schema: schemas.paginateSchema }, (req, rep) => controller.paginate(req, rep));
+    fastify.get('/api/audits/find', { schema: schemas.findSchema }, (req, rep) => controller.find(req, rep));
+    fastify.get('/api/audits/search', { schema: schemas.searchSchema }, (req, rep) => controller.search(req, rep));
+    fastify.get('/api/audits/:id', { schema: schemas.findByIdSchema }, (req, rep) => controller.findById(req, rep));
+    fastify.get('/api/audits/find-one', { schema: schemas.findOneSchema }, (req, rep) => controller.findOne(req, rep));
+    fastify.get('/api/audits/group-by', { schema: schemas.groupBySchema }, (req, rep) => controller.groupBy(req, rep));
+}
+export default AuditFastifyRoutes;
+export { AuditFastifyRoutes };

package/dist/schemas/AuditSchema.js

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+const AuditBaseSchema = z.object({
+    entity: z.string().min(1, 'validation.required'),
+    user: z.object({
+        id: z.string().min(1, 'validation.required'),
+        username: z.string().min(1, 'validation.required'),
+        rolName: z.string().optional().nullable()
+    }),
+    action: z.string().min(1, 'validation.required'),
+    ip: z.string().optional().nullable(),
+    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()
+    })).optional(),
+    sessionId: z.string().optional().nullable(),
+    requestId: z.string().optional().nullable(),
+    detail: z.string().optional().nullable(),
+    tenant: z.object({
+        id: z.string().optional().nullable(),
+        name: z.string().optional().nullable()
+    }).optional().nullable()
+});
+const AuditSchema = AuditBaseSchema
+    .extend({
+    _id: z.string(),
+    createdAt: z.date(),
+});
+export default AuditSchema;
+export { AuditSchema, AuditBaseSchema };

package/dist/services/AuditService.js

@@ -0,0 +1,8 @@
+import { AbstractService } from "@drax/crud-back";
+class AuditService extends AbstractService {
+    constructor(AuditRepository, schema) {
+        super(AuditRepository, schema);
+    }
+}
+export default AuditService;
+export { AuditService };

package/dist/utils/RegisterCrudEvent.js

@@ -0,0 +1,67 @@
+import { AuditServiceFactory } from "../factory/services/AuditServiceFactory.js";
+async function RegisterCrudEvent(crudEventData) {
+    function diff(preItem, postItem) {
+        const changes = [];
+        // Si no hay preItem (creación), no hay cambios que registrar
+        if (!preItem) {
+            return changes;
+        }
+        // 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') {
+                    changes.push({
+                        field: key,
+                        old: preItem[key],
+                        new: undefined
+                    });
+                }
+            });
+            return changes;
+        }
+        // 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') {
+                return;
+            }
+            const oldValue = preItem[key];
+            const newValue = postItem[key];
+            // Comparar valores
+            if (JSON.stringify(oldValue) !== JSON.stringify(newValue)) {
+                changes.push({
+                    field: key,
+                    old: oldValue,
+                    new: newValue
+                });
+            }
+        });
+        return changes;
+    }
+    let changes = diff(crudEventData.preItem, crudEventData.postItem);
+    let data = {
+        action: crudEventData.action,
+        changes: changes,
+        createdAt: crudEventData.timestamp,
+        detail: "",
+        entity: crudEventData.entity,
+        tenant: {
+            id: crudEventData.user.tenant.id,
+            name: crudEventData.user.tenant.name
+        },
+        user: {
+            id: crudEventData.user.id,
+            username: crudEventData.user.username,
+            rolName: crudEventData.user.role.name,
+        },
+        ip: crudEventData.ip,
+        userAgent: crudEventData.userAgent,
+        sessionId: crudEventData.user.session,
+        requestId: crudEventData.requestId
+    };
+    return await AuditServiceFactory.instance.create(data);
+}
+export { RegisterCrudEvent };
+export default RegisterCrudEvent;

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@drax/audit-back",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "0.38.0",
+  "description": "Audit backend",
+  "main": "dist/index.js",
+  "types": "types/index.d.ts",
+  "type": "module",
+  "scripts": {
+    "prepublish": "tsc && npm run copygql",
+    "tscrun": "tsc",
+    "clean": "rm -rf dist",
+    "copygql": "copyfiles -u 1 ./**/*.graphql dist/",
+    "tsc": "tsc -b tsconfig.json",
+    "test": "node --import tsx --test test/**/*",
+    "testService": "node --import tsx --test test/services/*.ts",
+    "testExports": "node --import tsx --test test/exports/*.ts",
+    "testWorkers": "node --import tsx --test test/workers/*.ts"
+  },
+  "author": "Cristian Incarnato & Drax Team",
+  "license": "ISC",
+  "dependencies": {
+    "@drax/crud-back": "^0.38.0",
+    "@drax/crud-share": "^0.38.0",
+    "mongoose": "^8.6.3",
+    "mongoose-paginate-v2": "^1.8.3"
+  },
+  "peerDependencies": {
+    "dayjs": "^1.11.19",
+    "mongoose-paginate-v2": "^1.8.3"
+  },
+  "devDependencies": {
+    "@types/node": "^20.12.10",
+    "copyfiles": "^2.4.1",
+    "mongoose-paginate-v2": "^1.8.3",
+    "ts-node": "^10.9.2",
+    "tsc-alias": "^1.8.10",
+    "typescript": "^5.6.2"
+  },
+  "gitHead": "43c90f3c12165e7527edefbc80dd327a59236dd5"
+}

package/src/controllers/AuditController.ts

@@ -0,0 +1,63 @@
+import AuditServiceFactory from "../factory/services/AuditServiceFactory.js";
+import {AbstractFastifyController} from "@drax/crud-back";
+import AuditPermissions from "../permissions/AuditPermissions.js";
+import type {IAudit, IAuditBase} from "@drax/audit-share";
+import type {FastifyReply, FastifyRequest} from "fastify";
+import {MethodNotAllowedError} from "@drax/common-back";
+
+class AuditController extends AbstractFastifyController<IAudit, IAuditBase, IAuditBase> {
+
+    constructor() {
+        super(AuditServiceFactory.instance, AuditPermissions)
+        this.tenantField = "tenant.id";
+        this.userField = "user";
+        this.tenantFilter = true;
+        this.userFilter = false;
+        this.tenantSetter = false;
+        this.userSetter = false;
+        this.tenantAssert = false;
+        this.userAssert = false;
+    }
+
+    async create(request: FastifyRequest, reply: FastifyReply): Promise<IAudit> {
+        try {
+            throw new MethodNotAllowedError()
+        } catch (e) {
+            this.handleError(e, reply)
+        }
+        return null;
+    }
+
+    async update(request: FastifyRequest, reply: FastifyReply): Promise<IAudit> {
+        try {
+            throw new MethodNotAllowedError()
+        } catch (e) {
+            this.handleError(e, reply)
+        }
+        return null;
+    }
+
+    async updatePartial(request: FastifyRequest, reply: FastifyReply): Promise<IAudit> {
+        try {
+            throw new MethodNotAllowedError()
+        } catch (e) {
+            this.handleError(e, reply)
+        }
+        return null;
+    }
+
+    async delete(request: FastifyRequest, reply: FastifyReply) {
+        try {
+            throw new MethodNotAllowedError()
+        } catch (e) {
+            this.handleError(e, reply)
+        }
+    }
+
+}
+
+export default AuditController;
+export {
+    AuditController
+}
+

package/src/factory/services/AuditServiceFactory.ts

@@ -0,0 +1,23 @@
+
+import AuditRepository from '../../repository/AuditRepository.js'
+import {AuditService} from '../../services/AuditService.js'
+import {AuditBaseSchema} from "../../schemas/AuditSchema.js";
+
+class AuditServiceFactory {
+    private static service: AuditService;
+
+    public static get instance(): AuditService {
+        if (!AuditServiceFactory.service) {
+            const repository = new AuditRepository();
+            const schema = AuditBaseSchema;
+            AuditServiceFactory.service = new AuditService(repository, schema);
+        }
+        return AuditServiceFactory.service;
+    }
+}
+
+export default AuditServiceFactory
+export {
+    AuditServiceFactory
+}
+

package/src/index.ts

@@ -0,0 +1,26 @@
+import AuditPermissions from './permissions/AuditPermissions.js'
+import AuditSchema from './schemas/AuditSchema.js'
+import AuditModel from './models/AuditModel.js'
+import AuditRepository from './repository/AuditRepository.js'
+import AuditService from './services/AuditService.js'
+import AuditServiceFactory from './factory/services/AuditServiceFactory.js'
+import AuditController from './controllers/AuditController.js'
+import AuditRoutes from './routes/AuditRoutes.js'
+import {RegisterCrudEvent} from './utils/RegisterCrudEvent.js'
+import type {IAuditRepository} from './interfaces/IAuditRepository'
+
+export type{
+    IAuditRepository
+}
+
+export {
+    AuditPermissions,
+    AuditSchema,
+    AuditModel,
+    AuditRepository,
+    AuditService,
+    AuditServiceFactory,
+    AuditController,
+    AuditRoutes,
+    RegisterCrudEvent
+}

package/src/interfaces/IAuditRepository.ts

@@ -0,0 +1,11 @@
+
+import type {IAudit, IAuditBase} from '@drax/audit-share'
+import {IDraxCrudRepository} from "@drax/crud-share";
+
+interface IAuditRepository extends IDraxCrudRepository<IAudit, IAuditBase, IAuditBase>{
+
+}
+
+export {IAuditRepository}
+
+

package/src/models/AuditModel.ts

@@ -0,0 +1,52 @@
+import {mongoose} from '@drax/common-back';
+import {PaginateModel} from "mongoose";
+import uniqueValidator from 'mongoose-unique-validator';
+import mongoosePaginate from 'mongoose-paginate-v2'
+import type {IAudit} from '@drax/audit-share'
+
+const AuditSchema = new mongoose.Schema<IAudit>({
+    entity: {type: String, required: true, index: true, unique: false},
+    user: {
+        id: {type: String, required: true, index: true, unique: false},
+        username: {type: String, required: true, index: false, unique: false},
+        rolName: {type: String, required: false, index: false, unique: false}
+    },
+    action: {type: String, required: true, index: true, unique: false},
+    ip: {type: String, required: false, index: false, unique: false},
+    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}
+    }],
+    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}
+    }
+}, {timestamps: true});
+
+AuditSchema.plugin(uniqueValidator, {message: 'validation.unique'});
+AuditSchema.plugin(mongoosePaginate);
+
+AuditSchema.virtual("id").get(function () {
+    return this._id.toString();
+});
+
+
+AuditSchema.set('toJSON', {getters: true, virtuals: true});
+
+AuditSchema.set('toObject', {getters: true, virtuals: true});
+
+const MODEL_NAME = 'Audit';
+const COLLECTION_NAME = 'Audit';
+const AuditModel = mongoose.model<IAudit, PaginateModel<IAudit>>(MODEL_NAME, AuditSchema, COLLECTION_NAME);
+
+export {
+    AuditSchema,
+    AuditModel
+}
+
+export default AuditModel

package/src/permissions/AuditPermissions.ts

@@ -0,0 +1,12 @@
+
+enum AuditPermissions {
+
+    View = "audit:view",
+    ViewAll = "audit:viewAll",
+    Manage = "audit:manage"
+
+}
+
+export { AuditPermissions };
+export default AuditPermissions;
+

package/src/repository/AuditRepository.ts

@@ -0,0 +1,21 @@
+
+import {AbstractMongoRepository} from "@drax/crud-back";
+import {AuditModel} from "../models/AuditModel.js";
+import type {IAuditRepository} from '../interfaces/IAuditRepository'
+import type {IAudit, IAuditBase} from "@drax/audit-share";
+
+
+class AuditMongoRepository extends AbstractMongoRepository<IAudit, IAuditBase, IAuditBase> implements IAuditRepository {
+
+    constructor() {
+        super();
+        this._model = AuditModel;
+        this._searchFields = ['entity', 'action', 'sessionId', 'requestId'];
+         this._populateFields = [];
+    }
+
+}
+
+export default AuditMongoRepository
+export {AuditMongoRepository}
+

package/src/routes/AuditRoutes.ts

@@ -0,0 +1,25 @@
+
+import AuditController from "../controllers/AuditController.js";
+import {CrudSchemaBuilder} from "@drax/crud-back";
+import {AuditSchema, AuditBaseSchema} from '../schemas/AuditSchema.js'
+
+async function AuditFastifyRoutes(fastify, options) {
+
+    const controller: AuditController = new AuditController()
+    const schemas = new CrudSchemaBuilder(AuditSchema, AuditBaseSchema,AuditBaseSchema, 'Audit', 'openApi3', ['Audit']);
+
+    fastify.get('/api/audits', {schema: schemas.paginateSchema}, (req,rep) => controller.paginate(req,rep))
+
+    fastify.get('/api/audits/find', {schema: schemas.findSchema}, (req,rep) => controller.find(req,rep))
+    fastify.get('/api/audits/search', {schema: schemas.searchSchema}, (req,rep) => controller.search(req,rep))
+
+    fastify.get('/api/audits/:id', {schema: schemas.findByIdSchema}, (req,rep) => controller.findById(req,rep))
+    fastify.get('/api/audits/find-one', {schema: schemas.findOneSchema}, (req,rep) => controller.findOne(req,rep))
+
+    fastify.get('/api/audits/group-by', {schema: schemas.groupBySchema}, (req,rep) => controller.groupBy(req,rep))
+
+
+}
+
+export default AuditFastifyRoutes;
+export {AuditFastifyRoutes}

package/src/schemas/AuditSchema.ts

@@ -0,0 +1,38 @@
+import {z} from 'zod';
+
+
+const AuditBaseSchema = z.object({
+    entity: z.string().min(1, 'validation.required'),
+    user: z.object({
+        id: z.string().min(1, 'validation.required'),
+        username: z.string().min(1, 'validation.required'),
+        rolName: z.string().optional().nullable()
+    }),
+    action: z.string().min(1, 'validation.required'),
+    ip: z.string().optional().nullable(),
+    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()
+        })
+    ).optional(),
+    sessionId: z.string().optional().nullable(),
+    requestId: z.string().optional().nullable(),
+    detail: z.string().optional().nullable(),
+    tenant: z.object({
+        id: z.string().optional().nullable(),
+        name: z.string().optional().nullable()
+    }).optional().nullable()
+});
+
+const AuditSchema = AuditBaseSchema
+    .extend({
+        _id: z.string(),
+        createdAt: z.date(),
+
+    })
+
+export default AuditSchema;
+export {AuditSchema, AuditBaseSchema}

package/src/services/AuditService.ts

@@ -0,0 +1,16 @@
+
+import type{IAuditRepository} from "../interfaces/IAuditRepository";
+import type {IAuditBase, IAudit} from "@drax/audit-share";
+import {AbstractService} from "@drax/crud-back";
+import type {ZodObject, ZodRawShape} from "zod";
+
+class AuditService extends AbstractService<IAudit, IAuditBase, IAuditBase> {
+
+    constructor(AuditRepository: IAuditRepository, schema?: ZodObject<ZodRawShape>) {
+        super(AuditRepository, schema);
+    }
+
+}
+
+export default AuditService
+export {AuditService}