rl-core-api 0.1.0

package/dist/core/websocket/baseGateway.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseGateway = void 0;
+const common_1 = require("@nestjs/common");
+const socket_constants_1 = require("./socket.constants");
+const socketEvent_envelope_1 = require("./socketEvent.envelope");
+const socketOrigin_util_1 = require("./socketOrigin.util");
+class BaseGateway {
+    constructor(wsAuth, env) {
+        this.wsAuth = wsAuth;
+        this.env = env;
+        this.logger = new common_1.Logger(this.constructor.name);
+    }
+    async handleConnection(socket) {
+        const resolved = await this.wsAuth.resolve(socket);
+        if (!resolved) {
+            socket.disconnect(true);
+            return;
+        }
+        if (resolved.source === "cookie") {
+            const allowed = (0, socketOrigin_util_1.parseAllowedOrigins)(this.env.get("CORS_ORIGIN"));
+            if (!(0, socketOrigin_util_1.isAllowedOrigin)(socket.handshake.headers.origin, allowed)) {
+                this.logger.warn(`Handshake recusado por origem: ${socket.handshake.headers.origin ?? "(ausente)"}`);
+                socket.disconnect(true);
+                return;
+            }
+        }
+        const data = socket.data;
+        data.user = resolved.user;
+        await socket.join([
+            (0, socket_constants_1.userRoom)(resolved.user.id),
+            ...resolved.user.roles.map(socket_constants_1.roleRoom),
+        ]);
+        this.scheduleExpiry(socket, resolved.expiresAt);
+    }
+    handleDisconnect(socket) {
+        const data = socket.data;
+        if (data.expiryTimer) {
+            clearTimeout(data.expiryTimer);
+        }
+        socket.removeAllListeners();
+    }
+    emitTo(rooms, event, data) {
+        const targets = rooms.filter((room) => room.length > 0);
+        if (targets.length === 0) {
+            this.logger.warn(`Evento ${event} descartado: sem sala de destino`);
+            return;
+        }
+        this.server.to(targets).emit(event, (0, socketEvent_envelope_1.wrapSocketEvent)(event, data));
+    }
+    scheduleExpiry(socket, expiresAt) {
+        const ms = expiresAt - Date.now();
+        if (ms <= 0) {
+            socket.disconnect(true);
+            return;
+        }
+        const data = socket.data;
+        const timer = setTimeout(() => socket.disconnect(true), ms);
+        timer.unref();
+        data.expiryTimer = timer;
+    }
+}
+exports.BaseGateway = BaseGateway;

package/dist/core/websocket/socket.constants.d.ts

@@ -0,0 +1,4 @@
+export declare const NOTIFICATIONS_NAMESPACE = "/notifications";
+export declare const userRoom: (userId: string) => string;
+export declare const roleRoom: (roleName: string) => string;
+export declare const SESSION_REFRESH_EVENT = "session:refresh";

package/dist/core/websocket/socket.constants.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SESSION_REFRESH_EVENT = exports.roleRoom = exports.userRoom = exports.NOTIFICATIONS_NAMESPACE = void 0;
+exports.NOTIFICATIONS_NAMESPACE = "/notifications";
+const userRoom = (userId) => `user:${userId}`;
+exports.userRoom = userRoom;
+const roleRoom = (roleName) => `role:${roleName}`;
+exports.roleRoom = roleRoom;
+exports.SESSION_REFRESH_EVENT = "session:refresh";

package/dist/core/websocket/socketEvent.envelope.d.ts

@@ -0,0 +1,8 @@
+export declare const SOCKET_EVENT_VERSION = 1;
+export interface SocketEvent<T> {
+    v: number;
+    event: string;
+    emittedAt: string;
+    data: T;
+}
+export declare const wrapSocketEvent: <T>(event: string, data: T) => SocketEvent<T>;

package/dist/core/websocket/socketEvent.envelope.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapSocketEvent = exports.SOCKET_EVENT_VERSION = void 0;
+exports.SOCKET_EVENT_VERSION = 1;
+const wrapSocketEvent = (event, data) => ({
+    v: exports.SOCKET_EVENT_VERSION,
+    event,
+    emittedAt: new Date().toISOString(),
+    data,
+});
+exports.wrapSocketEvent = wrapSocketEvent;

package/dist/core/websocket/socketOrigin.util.d.ts

@@ -0,0 +1,2 @@
+export declare const isAllowedOrigin: (origin: string | undefined, allowed: string[]) => boolean;
+export declare const parseAllowedOrigins: (corsOrigin: string) => string[];

package/dist/core/websocket/socketOrigin.util.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAllowedOrigins = exports.isAllowedOrigin = void 0;
+const isAllowedOrigin = (origin, allowed) => {
+    if (!origin) {
+        return false;
+    }
+    return allowed.some((entry) => entry.trim() === origin);
+};
+exports.isAllowedOrigin = isAllowedOrigin;
+const parseAllowedOrigins = (corsOrigin) => corsOrigin
+    .split(",")
+    .map((entry) => entry.trim())
+    .filter((entry) => entry.length > 0);
+exports.parseAllowedOrigins = parseAllowedOrigins;

package/dist/core/websocket/wsAuth.service.d.ts

@@ -0,0 +1,20 @@
+import { JwtService } from "@nestjs/jwt";
+import { Socket } from "socket.io";
+import { AuthenticatedUser } from "../auth/authenticatedUser.interface";
+import { EnvService } from "../config/env.service";
+import { WsUserResolver } from "./wsUserResolver.interface";
+export type WsTokenSource = "cookie" | "bearer";
+export interface ResolvedWsUser {
+    user: AuthenticatedUser;
+    source: WsTokenSource;
+    expiresAt: number;
+}
+export declare class WsAuthService {
+    private readonly jwt;
+    private readonly env;
+    private readonly resolver;
+    private readonly logger;
+    constructor(jwt: JwtService, env: EnvService, resolver: WsUserResolver);
+    resolve(socket: Socket): Promise<ResolvedWsUser | null>;
+    private extractToken;
+}

package/dist/core/websocket/wsAuth.service.js

@@ -0,0 +1,97 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var WsAuthService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WsAuthService = void 0;
+const common_1 = require("@nestjs/common");
+const jwt_1 = require("@nestjs/jwt");
+const cookie_util_1 = require("../auth/cookie.util");
+const env_service_1 = require("../config/env.service");
+const wsUserResolver_interface_1 = require("./wsUserResolver.interface");
+const readCookie = (header, name) => {
+    if (!header) {
+        return undefined;
+    }
+    for (const part of header.split(";")) {
+        const separator = part.indexOf("=");
+        if (separator < 0) {
+            continue;
+        }
+        if (part.slice(0, separator).trim() !== name) {
+            continue;
+        }
+        const value = part.slice(separator + 1).trim();
+        try {
+            return decodeURIComponent(value);
+        }
+        catch {
+            return value;
+        }
+    }
+    return undefined;
+};
+let WsAuthService = WsAuthService_1 = class WsAuthService {
+    constructor(jwt, env, resolver) {
+        this.jwt = jwt;
+        this.env = env;
+        this.resolver = resolver;
+        this.logger = new common_1.Logger(WsAuthService_1.name);
+    }
+    async resolve(socket) {
+        const extracted = this.extractToken(socket);
+        if (!extracted) {
+            return null;
+        }
+        try {
+            const claims = await this.jwt.verifyAsync(extracted.token, { secret: this.env.get("JWT_ACCESS_SECRET") });
+            if (claims.purpose !== "access") {
+                return null;
+            }
+            const user = await this.resolver.resolve(claims.sub);
+            if (!user) {
+                return null;
+            }
+            return {
+                user,
+                source: extracted.source,
+                expiresAt: claims.exp * 1000,
+            };
+        }
+        catch (err) {
+            this.logger.debug(`Handshake recusado: ${err instanceof Error ? err.message : "token inválido"}`);
+            return null;
+        }
+    }
+    extractToken(socket) {
+        const fromCookie = readCookie(socket.handshake.headers.cookie, cookie_util_1.ACCESS_COOKIE);
+        if (fromCookie) {
+            return { token: fromCookie, source: "cookie" };
+        }
+        const auth = socket.handshake.auth;
+        const fromAuth = typeof auth?.token === "string" ? auth.token : undefined;
+        const fromHeader = socket.handshake.headers.authorization;
+        const bearer = fromAuth ?? fromHeader;
+        if (bearer) {
+            return { token: bearer.replace(/^Bearer\s+/i, ""), source: "bearer" };
+        }
+        return null;
+    }
+};
+exports.WsAuthService = WsAuthService;
+exports.WsAuthService = WsAuthService = WsAuthService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(2, (0, common_1.Inject)(wsUserResolver_interface_1.WS_USER_RESOLVER)),
+    __metadata("design:paramtypes", [jwt_1.JwtService,
+        env_service_1.EnvService, Object])
+], WsAuthService);

package/dist/core/websocket/wsUserResolver.interface.d.ts

@@ -0,0 +1,5 @@
+import { AuthenticatedUser } from "../auth/authenticatedUser.interface";
+export interface WsUserResolver {
+    resolve(userId: string): Promise<AuthenticatedUser | null>;
+}
+export declare const WS_USER_RESOLVER = "WS_USER_RESOLVER";

package/dist/core/websocket/wsUserResolver.interface.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WS_USER_RESOLVER = void 0;
+exports.WS_USER_RESOLVER = "WS_USER_RESOLVER";

package/dist/coreEntities.d.ts

@@ -0,0 +1,12 @@
+import { AuditChange } from "./features/audit/infra/schema/auditChange.schema";
+import { AuditDataChange } from "./features/audit/infra/schema/auditDataChange.schema";
+import { ErrorLog } from "./features/audit/infra/schema/errorLog.schema";
+import { AuthToken } from "./features/auth/infra/schema/authToken.schema";
+import { Notification } from "./features/notifications/infra/schema/notification.schema";
+import { NotificationRead } from "./features/notifications/infra/schema/notificationRead.schema";
+import { NotificationScope } from "./features/notifications/infra/schema/notificationScope.schema";
+import { Action } from "./features/rbac/infra/schema/action.schema";
+import { Permission } from "./features/rbac/infra/schema/permission.schema";
+import { PasswordHistory } from "./features/users/infra/schema/passwordHistory.schema";
+import { User } from "./features/users/infra/schema/user.schema";
+export declare const coreEntities: (typeof AuditChange | typeof AuditDataChange | typeof ErrorLog | typeof AuthToken | typeof NotificationRead | typeof Notification | typeof NotificationScope | typeof Action | typeof Permission | typeof PasswordHistory | typeof User)[];

package/dist/coreEntities.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.coreEntities = void 0;
+const auditChange_schema_1 = require("./features/audit/infra/schema/auditChange.schema");
+const auditDataChange_schema_1 = require("./features/audit/infra/schema/auditDataChange.schema");
+const errorLog_schema_1 = require("./features/audit/infra/schema/errorLog.schema");
+const authToken_schema_1 = require("./features/auth/infra/schema/authToken.schema");
+const notification_schema_1 = require("./features/notifications/infra/schema/notification.schema");
+const notificationRead_schema_1 = require("./features/notifications/infra/schema/notificationRead.schema");
+const notificationScope_schema_1 = require("./features/notifications/infra/schema/notificationScope.schema");
+const action_schema_1 = require("./features/rbac/infra/schema/action.schema");
+const group_schema_1 = require("./features/rbac/infra/schema/group.schema");
+const permission_schema_1 = require("./features/rbac/infra/schema/permission.schema");
+const resource_schema_1 = require("./features/rbac/infra/schema/resource.schema");
+const role_schema_1 = require("./features/rbac/infra/schema/role.schema");
+const scope_schema_1 = require("./features/rbac/infra/schema/scope.schema");
+const passwordHistory_schema_1 = require("./features/users/infra/schema/passwordHistory.schema");
+const user_schema_1 = require("./features/users/infra/schema/user.schema");
+exports.coreEntities = [
+    user_schema_1.User,
+    passwordHistory_schema_1.PasswordHistory,
+    authToken_schema_1.AuthToken,
+    resource_schema_1.Resource,
+    action_schema_1.Action,
+    scope_schema_1.Scope,
+    permission_schema_1.Permission,
+    role_schema_1.Role,
+    group_schema_1.Group,
+    auditChange_schema_1.AuditChange,
+    errorLog_schema_1.ErrorLog,
+    auditDataChange_schema_1.AuditDataChange,
+    notification_schema_1.Notification,
+    notificationScope_schema_1.NotificationScope,
+    notificationRead_schema_1.NotificationRead,
+];

package/dist/dataSource.d.ts

@@ -0,0 +1,3 @@
+import "reflect-metadata";
+import { DataSource } from "typeorm";
+export declare const AppDataSource: DataSource;

package/dist/dataSource.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppDataSource = void 0;
+require("reflect-metadata");
+const dotenv_1 = require("dotenv");
+const createDataSource_util_1 = require("./core/database/createDataSource.util");
+const migrations_1 = require("./core/database/migrations");
+const coreEntities_1 = require("./coreEntities");
+(0, dotenv_1.config)();
+exports.AppDataSource = (0, createDataSource_util_1.createCoreDataSource)({
+    entities: coreEntities_1.coreEntities,
+    migrations: migrations_1.coreMigrations,
+});

package/dist/features/audit/audit.module.d.ts

@@ -0,0 +1,2 @@
+export declare class AuditModule {
+}

package/dist/features/audit/audit.module.js

@@ -0,0 +1,44 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuditModule = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const typeorm_1 = require("@nestjs/typeorm");
+const domain_1 = require("./domain");
+const infra_1 = require("./infra");
+const presentation_1 = require("./presentation");
+const user_repository_1 = require("../users/infra/repositories/user.repository");
+const user_schema_1 = require("../users/infra/schema/user.schema");
+let AuditModule = class AuditModule {
+};
+exports.AuditModule = AuditModule;
+exports.AuditModule = AuditModule = __decorate([
+    (0, common_1.Module)({
+        imports: [
+            typeorm_1.TypeOrmModule.forFeature([infra_1.AuditChange, infra_1.ErrorLog, infra_1.AuditDataChange, user_schema_1.User]),
+        ],
+        controllers: [presentation_1.AuditController],
+        providers: [
+            infra_1.AuditChangeRepository,
+            infra_1.ErrorLogRepository,
+            infra_1.AuditDataChangeRepository,
+            user_repository_1.UserRepository,
+            domain_1.AuditService,
+            { provide: core_1.APP_INTERCEPTOR, useClass: presentation_1.AuditInterceptor },
+            infra_1.AuditDataSubscriber,
+        ],
+        exports: [
+            infra_1.AuditChangeRepository,
+            infra_1.ErrorLogRepository,
+            infra_1.AuditDataChangeRepository,
+            user_repository_1.UserRepository,
+            domain_1.AuditService,
+        ],
+    })
+], AuditModule);

package/dist/features/audit/domain/audit.service.d.ts

@@ -0,0 +1,34 @@
+import { Paginated, PaginationQuery } from "../../../core/utils/pagination.util";
+import { AuditChangeRepository } from "../infra/repositories/auditChange.repository";
+import { AuditDataChangeRepository } from "../infra/repositories/auditDataChange.repository";
+import { ErrorLogRepository } from "../infra/repositories/errorLog.repository";
+import { AuditChange } from "../infra/schema/auditChange.schema";
+import { AuditDataChange } from "../infra/schema/auditDataChange.schema";
+import { ErrorLog } from "../infra/schema/errorLog.schema";
+import { UserRepository } from "../../users/infra/repositories/user.repository";
+export type WithUserRef<T> = T & {
+    user?: {
+        id: string;
+        name: string;
+        email: string;
+    } | null;
+};
+export type AuditDataChangeWithUser = WithUserRef<Pick<AuditDataChange, "id" | "createdAt" | "updatedAt" | "deletedAt" | "entity" | "entityId" | "action" | "oldData" | "newData" | "userId" | "ipAddress">>;
+export declare class AuditService {
+    private readonly changeRepo;
+    private readonly errorRepo;
+    private readonly dataChangeRepo;
+    private readonly userRepo;
+    private readonly logger;
+    constructor(changeRepo: AuditChangeRepository, errorRepo: ErrorLogRepository, dataChangeRepo: AuditDataChangeRepository, userRepo: UserRepository);
+    recordChange(data: Partial<AuditChange>): Promise<void>;
+    recordError(data: Partial<ErrorLog>): Promise<void>;
+    cleanupOldLogs(retentionDays: number): Promise<{
+        changes: number;
+        errors: number;
+    }>;
+    listChanges(query: PaginationQuery): Promise<Paginated<WithUserRef<AuditChange>>>;
+    listErrors(query: PaginationQuery): Promise<Paginated<WithUserRef<ErrorLog>>>;
+    listDataChanges(query: PaginationQuery): Promise<Paginated<AuditDataChangeWithUser>>;
+    private enrichWithUser;
+}

package/dist/features/audit/domain/audit.service.js

@@ -0,0 +1,93 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var AuditService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuditService = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("typeorm");
+const pagination_util_1 = require("../../../core/utils/pagination.util");
+const auditChange_repository_1 = require("../infra/repositories/auditChange.repository");
+const auditDataChange_repository_1 = require("../infra/repositories/auditDataChange.repository");
+const errorLog_repository_1 = require("../infra/repositories/errorLog.repository");
+const user_repository_1 = require("../../users/infra/repositories/user.repository");
+let AuditService = AuditService_1 = class AuditService {
+    constructor(changeRepo, errorRepo, dataChangeRepo, userRepo) {
+        this.changeRepo = changeRepo;
+        this.errorRepo = errorRepo;
+        this.dataChangeRepo = dataChangeRepo;
+        this.userRepo = userRepo;
+        this.logger = new common_1.Logger(AuditService_1.name);
+    }
+    async recordChange(data) {
+        try {
+            await this.changeRepo.save(this.changeRepo.create(data));
+        }
+        catch (err) {
+            this.logger.warn(`Falha ao gravar AuditChange: ${err.message}`);
+        }
+    }
+    async recordError(data) {
+        try {
+            await this.errorRepo.save(this.errorRepo.create(data));
+        }
+        catch (err) {
+            this.logger.warn(`Falha ao gravar ErrorLog: ${err.message}`);
+        }
+    }
+    async cleanupOldLogs(retentionDays) {
+        const cutoff = new Date(Date.now() - retentionDays * 24 * 60 * 60 * 1000);
+        const changes = await this.changeRepo.delete({
+            createdAt: (0, typeorm_1.LessThan)(cutoff),
+        });
+        const errors = await this.errorRepo.delete({ createdAt: (0, typeorm_1.LessThan)(cutoff) });
+        return { changes: changes.affected ?? 0, errors: errors.affected ?? 0 };
+    }
+    async listChanges(query) {
+        const [items, total] = await this.changeRepo.findPaginated(query);
+        return new pagination_util_1.Paginated(await this.enrichWithUser(items), total, query.page, query.limit);
+    }
+    async listErrors(query) {
+        const [items, total] = await this.errorRepo.findPaginated(query);
+        return new pagination_util_1.Paginated(await this.enrichWithUser(items), total, query.page, query.limit);
+    }
+    async listDataChanges(query) {
+        const [items, total] = await this.dataChangeRepo.findPaginated(query);
+        return new pagination_util_1.Paginated(await this.enrichWithUser(items), total, query.page, query.limit);
+    }
+    async enrichWithUser(items) {
+        const userIds = [
+            ...new Set(items.map((i) => i.userId).filter((id) => !!id)),
+        ];
+        const usersById = new Map();
+        if (userIds.length) {
+            const users = await this.userRepo.find({
+                where: { id: (0, typeorm_1.In)(userIds) },
+                withDeleted: true,
+            });
+            users.forEach((u) => usersById.set(u.id, u));
+        }
+        return items.map((item) => {
+            const user = item.userId ? usersById.get(item.userId) : undefined;
+            return {
+                ...item,
+                user: user ? { id: user.id, name: user.name, email: user.email } : null,
+            };
+        });
+    }
+};
+exports.AuditService = AuditService;
+exports.AuditService = AuditService = AuditService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [auditChange_repository_1.AuditChangeRepository,
+        errorLog_repository_1.ErrorLogRepository,
+        auditDataChange_repository_1.AuditDataChangeRepository,
+        user_repository_1.UserRepository])
+], AuditService);

package/dist/features/audit/domain/classifyError.util.d.ts

@@ -0,0 +1,2 @@
+import { ErrorType } from "../infra/schema/errorLog.schema";
+export declare function classifyError(exception: unknown, status: number): ErrorType;

package/dist/features/audit/domain/classifyError.util.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyError = classifyError;
+const errorLog_schema_1 = require("../infra/schema/errorLog.schema");
+function classifyError(exception, status) {
+    if (status === 400) {
+        return errorLog_schema_1.ErrorType.VALIDATION;
+    }
+    if (status === 401 || status === 403) {
+        return errorLog_schema_1.ErrorType.AUTH;
+    }
+    if (status === 404) {
+        return errorLog_schema_1.ErrorType.NOT_FOUND;
+    }
+    if (status === 429) {
+        return errorLog_schema_1.ErrorType.RATE_LIMIT;
+    }
+    const name = exception?.name ?? "";
+    if (name.includes("QueryFailedError") ||
+        name.includes("EntityNotFoundError")) {
+        return errorLog_schema_1.ErrorType.DATABASE;
+    }
+    return errorLog_schema_1.ErrorType.INTERNAL;
+}

package/dist/features/audit/domain/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./audit.service";
+export * from "./classifyError.util";

package/dist/features/audit/domain/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./audit.service"), exports);
+__exportStar(require("./classifyError.util"), exports);

package/dist/features/audit/infra/auditData.subscriber.d.ts

@@ -0,0 +1,17 @@
+import { DataSource, EntitySubscriberInterface, InsertEvent, ObjectLiteral, RemoveEvent, SoftRemoveEvent, UpdateEvent } from "typeorm";
+interface AuditableEntity extends ObjectLiteral {
+    id?: string;
+}
+export declare class AuditDataSubscriber implements EntitySubscriberInterface {
+    private readonly logger;
+    constructor(dataSource: DataSource);
+    afterInsert(event: InsertEvent<AuditableEntity>): Promise<void>;
+    afterUpdate(event: UpdateEvent<AuditableEntity>): Promise<void>;
+    afterRemove(event: RemoveEvent<AuditableEntity>): Promise<void>;
+    afterSoftRemove(event: SoftRemoveEvent<AuditableEntity>): Promise<void>;
+    private recordRemoval;
+    private snapshot;
+    private serialize;
+    private persist;
+}
+export {};