rl-core-api 0.1.0

package/dist/features/auth/presentation/strategies/jwt.strategy.js

@@ -0,0 +1,59 @@
+"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 JwtStrategy_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JwtStrategy = void 0;
+const common_1 = require("@nestjs/common");
+const passport_1 = require("@nestjs/passport");
+const passport_jwt_1 = require("passport-jwt");
+const env_service_1 = require("../../../../core/config/env.service");
+const auth_service_1 = require("../../domain/auth.service");
+const users_service_1 = require("../../../users/domain/users.service");
+const cookieExtractor = (req) => {
+    const cookies = req?.cookies;
+    return cookies?.access_token ?? null;
+};
+let JwtStrategy = JwtStrategy_1 = class JwtStrategy extends (0, passport_1.PassportStrategy)(passport_jwt_1.Strategy, "jwt") {
+    constructor(env, users, auth) {
+        super({
+            jwtFromRequest: passport_jwt_1.ExtractJwt.fromExtractors([
+                cookieExtractor,
+                passport_jwt_1.ExtractJwt.fromAuthHeaderAsBearerToken(),
+            ]),
+            ignoreExpiration: false,
+            secretOrKey: env.get("JWT_ACCESS_SECRET"),
+        });
+        this.env = env;
+        this.users = users;
+        this.auth = auth;
+        this.logger = new common_1.Logger(JwtStrategy_1.name);
+    }
+    async validate(payload) {
+        if (payload.purpose !== "access") {
+            throw new common_1.UnauthorizedException("Token inválido para esta operação");
+        }
+        const user = await this.users.findById(payload.sub).catch((err) => {
+            this.logger.warn(`Falha ao buscar usuário autenticado (${payload.sub}): ${err.message}`);
+            return null;
+        });
+        if (!user || !user.isActive) {
+            throw new common_1.UnauthorizedException("Usuário inválido ou inativo");
+        }
+        return this.auth.toSessionUser(user);
+    }
+};
+exports.JwtStrategy = JwtStrategy;
+exports.JwtStrategy = JwtStrategy = JwtStrategy_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [env_service_1.EnvService,
+        users_service_1.UsersService,
+        auth_service_1.AuthService])
+], JwtStrategy);

package/dist/features/auth/token.module.d.ts

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

package/dist/features/auth/token.module.js

@@ -0,0 +1,23 @@
+"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.TokenModule = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const domain_1 = require("./domain");
+const infra_1 = require("./infra");
+let TokenModule = class TokenModule {
+};
+exports.TokenModule = TokenModule;
+exports.TokenModule = TokenModule = __decorate([
+    (0, common_1.Module)({
+        imports: [typeorm_1.TypeOrmModule.forFeature([infra_1.AuthToken])],
+        providers: [infra_1.AuthTokenRepository, domain_1.TokenService],
+        exports: [infra_1.AuthTokenRepository, domain_1.TokenService],
+    })
+], TokenModule);

package/dist/features/maintenance/domain/cleanup.service.d.ts

@@ -0,0 +1,22 @@
+import { EventEmitter2 } from "@nestjs/event-emitter";
+import { EnvService } from "../../../core/config/env.service";
+import { AuditService } from "../../audit/domain/audit.service";
+import { TokenService } from "../../auth/domain/token.service";
+import { NotificationsService } from "../../notifications/domain/notifications.service";
+import { UserRepository } from "../../users/infra/repositories/user.repository";
+export declare class CleanupService {
+    private readonly tokens;
+    private readonly audit;
+    private readonly env;
+    private readonly notifications;
+    private readonly users;
+    private readonly events;
+    private readonly logger;
+    constructor(tokens: TokenService, audit: AuditService, env: EnvService, notifications: NotificationsService, users: UserRepository, events: EventEmitter2);
+    handleTokenCleanup(): Promise<void>;
+    handleAuditLogCleanup(): Promise<void>;
+    handleNotificationCleanup(): Promise<void>;
+    handlePasswordExpiryWarning(): Promise<void>;
+    private daysUntilExpiry;
+    private run;
+}

package/dist/features/maintenance/domain/cleanup.service.js

@@ -0,0 +1,142 @@
+"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 CleanupService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CleanupService = void 0;
+const common_1 = require("@nestjs/common");
+const event_emitter_1 = require("@nestjs/event-emitter");
+const schedule_1 = require("@nestjs/schedule");
+const env_service_1 = require("../../../core/config/env.service");
+const appEvent_enum_1 = require("../../../core/events/appEvent.enum");
+const audit_service_1 = require("../../audit/domain/audit.service");
+const token_service_1 = require("../../auth/domain/token.service");
+const notifications_service_1 = require("../../notifications/domain/notifications.service");
+const user_repository_1 = require("../../users/infra/repositories/user.repository");
+const PASSWORD_WARNING_MILESTONES = [7, 3, 1];
+let CleanupService = CleanupService_1 = class CleanupService {
+    constructor(tokens, audit, env, notifications, users, events) {
+        this.tokens = tokens;
+        this.audit = audit;
+        this.env = env;
+        this.notifications = notifications;
+        this.users = users;
+        this.events = events;
+        this.logger = new common_1.Logger(CleanupService_1.name);
+    }
+    async handleTokenCleanup() {
+        await this.run("Limpeza de tokens", async () => {
+            const removed = await this.tokens.cleanExpired();
+            if (removed > 0) {
+                this.logger.log(`Tokens expirados removidos: ${removed}`);
+            }
+        });
+    }
+    async handleAuditLogCleanup() {
+        await this.run("Limpeza de logs operacionais", async () => {
+            const retentionDays = this.env.get("AUDIT_LOG_RETENTION_DAYS");
+            const { changes, errors } = await this.audit.cleanupOldLogs(retentionDays);
+            if (changes > 0 || errors > 0) {
+                this.logger.log(`Logs operacionais removidos (> ${retentionDays}d): ${changes} requisições, ${errors} erros`);
+            }
+        });
+    }
+    async handleNotificationCleanup() {
+        await this.run("Limpeza de notificações", async () => {
+            const retentionDays = this.env.get("NOTIFICATION_RETENTION_DAYS");
+            const removed = await this.notifications.cleanupOldRead(retentionDays);
+            if (removed > 0) {
+                this.logger.log(`Notificações lidas removidas (> ${retentionDays}d): ${removed}`);
+            }
+        });
+    }
+    async handlePasswordExpiryWarning() {
+        await this.run("Aviso de senha a vencer", async () => {
+            const maxAge = this.env.get("PASSWORD_MAX_AGE_DAYS");
+            const candidates = await this.users.findWithPasswordExpiringIn(maxAge, PASSWORD_WARNING_MILESTONES);
+            for (const user of candidates) {
+                const daysLeft = this.daysUntilExpiry(user.passwordChangedAt, maxAge);
+                if (!PASSWORD_WARNING_MILESTONES.includes(daysLeft)) {
+                    continue;
+                }
+                this.events.emit(appEvent_enum_1.AppEvent.USER_PASSWORD_EXPIRING, {
+                    userId: user.id,
+                    daysLeft,
+                });
+            }
+        });
+    }
+    daysUntilExpiry(passwordChangedAt, maxAgeDays) {
+        if (!passwordChangedAt) {
+            return -1;
+        }
+        const expiresAt = new Date(passwordChangedAt);
+        expiresAt.setDate(expiresAt.getDate() + maxAgeDays);
+        expiresAt.setHours(0, 0, 0, 0);
+        const today = new Date();
+        today.setHours(0, 0, 0, 0);
+        return Math.round((expiresAt.getTime() - today.getTime()) / (24 * 60 * 60 * 1000));
+    }
+    async run(routine, job) {
+        try {
+            await job();
+        }
+        catch (err) {
+            const reason = err instanceof Error ? err.message : String(err);
+            this.logger.error(`${routine} falhou: ${reason}`);
+            this.events.emit(appEvent_enum_1.AppEvent.SYSTEM_CLEANUP_FAILED, {
+                routine,
+                reason,
+            });
+        }
+    }
+};
+exports.CleanupService = CleanupService;
+__decorate([
+    (0, schedule_1.Cron)(process.env.TOKEN_CLEANUP_CRON ?? "0 */6 * * *", {
+        name: "token-cleanup",
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], CleanupService.prototype, "handleTokenCleanup", null);
+__decorate([
+    (0, schedule_1.Cron)(process.env.AUDIT_LOG_CLEANUP_CRON ?? "0 3 * * *", {
+        name: "audit-log-cleanup",
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], CleanupService.prototype, "handleAuditLogCleanup", null);
+__decorate([
+    (0, schedule_1.Cron)(process.env.NOTIFICATION_CLEANUP_CRON ?? "0 4 * * *", {
+        name: "notification-cleanup",
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], CleanupService.prototype, "handleNotificationCleanup", null);
+__decorate([
+    (0, schedule_1.Cron)(process.env.PASSWORD_EXPIRY_WARNING_CRON ?? "0 8 * * *", {
+        name: "password-expiry-warning",
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], CleanupService.prototype, "handlePasswordExpiryWarning", null);
+exports.CleanupService = CleanupService = CleanupService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [token_service_1.TokenService,
+        audit_service_1.AuditService,
+        env_service_1.EnvService,
+        notifications_service_1.NotificationsService,
+        user_repository_1.UserRepository,
+        event_emitter_1.EventEmitter2])
+], CleanupService);

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

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

package/dist/features/maintenance/maintenance.module.js

@@ -0,0 +1,24 @@
+"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.MaintenanceModule = void 0;
+const common_1 = require("@nestjs/common");
+const audit_module_1 = require("../audit/audit.module");
+const auth_module_1 = require("../auth/auth.module");
+const cleanup_service_1 = require("./domain/cleanup.service");
+const notifications_module_1 = require("../notifications/notifications.module");
+const users_module_1 = require("../users/users.module");
+let MaintenanceModule = class MaintenanceModule {
+};
+exports.MaintenanceModule = MaintenanceModule;
+exports.MaintenanceModule = MaintenanceModule = __decorate([
+    (0, common_1.Module)({
+        imports: [auth_module_1.AuthModule, audit_module_1.AuditModule, notifications_module_1.NotificationsModule, users_module_1.UsersModule],
+        providers: [cleanup_service_1.CleanupService],
+    })
+], MaintenanceModule);

package/dist/features/notifications/domain/enums/channelType.enum.d.ts

@@ -0,0 +1,7 @@
+export declare enum ChannelType {
+    IN_APP = "IN_APP",
+    EMAIL = "EMAIL",
+    PUSH = "PUSH",
+    SMS = "SMS",
+    WHATSAPP = "WHATSAPP"
+}

package/dist/features/notifications/domain/enums/channelType.enum.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelType = void 0;
+var ChannelType;
+(function (ChannelType) {
+    ChannelType["IN_APP"] = "IN_APP";
+    ChannelType["EMAIL"] = "EMAIL";
+    ChannelType["PUSH"] = "PUSH";
+    ChannelType["SMS"] = "SMS";
+    ChannelType["WHATSAPP"] = "WHATSAPP";
+})(ChannelType || (exports.ChannelType = ChannelType = {}));

package/dist/features/notifications/domain/enums/deliveryStatus.enum.d.ts

@@ -0,0 +1,8 @@
+export declare enum DeliveryStatus {
+    PENDING = "PENDING",
+    QUEUED = "QUEUED",
+    SENT = "SENT",
+    DELIVERED = "DELIVERED",
+    FAILED = "FAILED",
+    CANCELLED = "CANCELLED"
+}

package/dist/features/notifications/domain/enums/deliveryStatus.enum.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeliveryStatus = void 0;
+var DeliveryStatus;
+(function (DeliveryStatus) {
+    DeliveryStatus["PENDING"] = "PENDING";
+    DeliveryStatus["QUEUED"] = "QUEUED";
+    DeliveryStatus["SENT"] = "SENT";
+    DeliveryStatus["DELIVERED"] = "DELIVERED";
+    DeliveryStatus["FAILED"] = "FAILED";
+    DeliveryStatus["CANCELLED"] = "CANCELLED";
+})(DeliveryStatus || (exports.DeliveryStatus = DeliveryStatus = {}));

package/dist/features/notifications/domain/enums/notificationType.enum.d.ts

@@ -0,0 +1,6 @@
+export declare enum NotificationType {
+    INFO = "INFO",
+    SUCCESS = "SUCCESS",
+    WARNING = "WARNING",
+    ERROR = "ERROR"
+}

package/dist/features/notifications/domain/enums/notificationType.enum.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationType = void 0;
+var NotificationType;
+(function (NotificationType) {
+    NotificationType["INFO"] = "INFO";
+    NotificationType["SUCCESS"] = "SUCCESS";
+    NotificationType["WARNING"] = "WARNING";
+    NotificationType["ERROR"] = "ERROR";
+})(NotificationType || (exports.NotificationType = NotificationType = {}));

package/dist/features/notifications/domain/enums/scopeType.enum.d.ts

@@ -0,0 +1,5 @@
+export declare enum ScopeType {
+    USER = "USER",
+    ROLE = "ROLE",
+    ALL = "ALL"
+}

package/dist/features/notifications/domain/enums/scopeType.enum.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScopeType = void 0;
+var ScopeType;
+(function (ScopeType) {
+    ScopeType["USER"] = "USER";
+    ScopeType["ROLE"] = "ROLE";
+    ScopeType["ALL"] = "ALL";
+})(ScopeType || (exports.ScopeType = ScopeType = {}));

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

@@ -0,0 +1,45 @@
+import { DataSource } from "typeorm";
+import { AuthenticatedUser } from "../../../core/auth/authenticatedUser.interface";
+import { Paginated, PaginationQuery } from "../../../core/utils/pagination.util";
+import { NotificationType } from "./enums/notificationType.enum";
+import { ScopeType } from "./enums/scopeType.enum";
+import { NotificationRepository } from "../infra/repositories/notification.repository";
+import { NotificationReadRepository } from "../infra/repositories/notificationRead.repository";
+import { NotificationScopeRepository } from "../infra/repositories/notificationScope.repository";
+import { Notification } from "../infra/schema/notification.schema";
+export interface NotificationTarget {
+    type: ScopeType;
+    key?: string | null;
+}
+export interface PublishNotificationParams {
+    title: string;
+    body: string;
+    type: NotificationType;
+    targets: NotificationTarget[];
+    payload?: Record<string, unknown> | null;
+    createdBy?: string | null;
+}
+export interface UserNotification {
+    id: string;
+    title: string;
+    body: string;
+    type: NotificationType;
+    route: string | null;
+    read: boolean;
+    createdAt: Date;
+}
+export declare class NotificationsService {
+    private readonly notifications;
+    private readonly scopes;
+    private readonly reads;
+    private readonly dataSource;
+    constructor(notifications: NotificationRepository, scopes: NotificationScopeRepository, reads: NotificationReadRepository, dataSource: DataSource);
+    publish(params: PublishNotificationParams): Promise<Notification>;
+    findByUser(user: AuthenticatedUser, query: PaginationQuery): Promise<Paginated<UserNotification>>;
+    countUnread(user: AuthenticatedUser): Promise<number>;
+    markAsRead(id: string, user: AuthenticatedUser): Promise<void>;
+    markAllAsRead(user: AuthenticatedUser): Promise<void>;
+    cleanupOldRead(retentionDays: number): Promise<number>;
+    private visibilityOf;
+    private toUserNotification;
+}

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

@@ -0,0 +1,101 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationsService = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("typeorm");
+const pagination_util_1 = require("../../../core/utils/pagination.util");
+const scopeType_enum_1 = require("./enums/scopeType.enum");
+const notification_repository_1 = require("../infra/repositories/notification.repository");
+const notificationRead_repository_1 = require("../infra/repositories/notificationRead.repository");
+const notificationScope_repository_1 = require("../infra/repositories/notificationScope.repository");
+const notification_schema_1 = require("../infra/schema/notification.schema");
+const notificationScope_schema_1 = require("../infra/schema/notificationScope.schema");
+let NotificationsService = class NotificationsService {
+    constructor(notifications, scopes, reads, dataSource) {
+        this.notifications = notifications;
+        this.scopes = scopes;
+        this.reads = reads;
+        this.dataSource = dataSource;
+    }
+    async publish(params) {
+        return await this.dataSource.transaction(async (manager) => {
+            const notification = manager.create(notification_schema_1.Notification, {
+                title: params.title,
+                body: params.body,
+                type: params.type,
+                payload: params.payload ?? null,
+                createdBy: params.createdBy ?? null,
+            });
+            const saved = await manager.save(notification);
+            const scopes = params.targets.map((target) => manager.create(notificationScope_schema_1.NotificationScope, {
+                notificationId: saved.id,
+                scopeType: target.type,
+                scopeKey: target.type === scopeType_enum_1.ScopeType.ALL ? null : target.key,
+            }));
+            await manager.save(scopes);
+            return saved;
+        });
+    }
+    async findByUser(user, query) {
+        const { page, limit } = query;
+        const [items, total] = await this.notifications.findVisibleToUser(this.visibilityOf(user), page, limit);
+        return new pagination_util_1.Paginated(items.map((item) => this.toUserNotification(item)), total, page, limit);
+    }
+    async countUnread(user) {
+        return await this.notifications.countUnread(this.visibilityOf(user));
+    }
+    async markAsRead(id, user) {
+        const visible = await this.notifications.isVisibleToUser(id, this.visibilityOf(user));
+        if (!visible) {
+            throw new common_1.NotFoundException("Notificação não encontrada");
+        }
+        await this.reads.markAsRead([id], user.id);
+    }
+    async markAllAsRead(user) {
+        const ids = await this.notifications.findUnreadIds(this.visibilityOf(user));
+        await this.reads.markAsRead(ids, user.id);
+    }
+    async cleanupOldRead(retentionDays) {
+        const limit = new Date();
+        limit.setDate(limit.getDate() - retentionDays);
+        const result = await this.notifications
+            .createQueryBuilder()
+            .softDelete()
+            .where("created_at < :limit", { limit })
+            .andWhere(`EXISTS (SELECT 1 FROM notification_reads r WHERE r.notification_id = id)`)
+            .execute();
+        return result.affected ?? 0;
+    }
+    visibilityOf(user) {
+        return { userId: user.id, roleNames: user.roles ?? [] };
+    }
+    toUserNotification(notification) {
+        const payload = notification.payload;
+        return {
+            id: notification.id,
+            title: notification.title,
+            body: notification.body,
+            type: notification.type,
+            route: payload?.route ?? null,
+            read: (notification.reads?.length ?? 0) > 0,
+            createdAt: notification.createdAt,
+        };
+    }
+};
+exports.NotificationsService = NotificationsService;
+exports.NotificationsService = NotificationsService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [notification_repository_1.NotificationRepository,
+        notificationScope_repository_1.NotificationScopeRepository,
+        notificationRead_repository_1.NotificationReadRepository,
+        typeorm_1.DataSource])
+], NotificationsService);

package/dist/features/notifications/infra/repositories/notification.repository.d.ts

@@ -0,0 +1,14 @@
+import { DataSource, Repository } from "typeorm";
+import { Notification } from "../schema/notification.schema";
+export interface VisibilityParams {
+    userId: string;
+    roleNames: string[];
+}
+export declare class NotificationRepository extends Repository<Notification> {
+    constructor(dataSource: DataSource);
+    findVisibleToUser(params: VisibilityParams, page: number, limit: number): Promise<[Notification[], number]>;
+    countUnread(params: VisibilityParams): Promise<number>;
+    isVisibleToUser(notificationId: string, params: VisibilityParams): Promise<boolean>;
+    findUnreadIds(params: VisibilityParams): Promise<string[]>;
+    private baseVisibleQuery;
+}

package/dist/features/notifications/infra/repositories/notification.repository.js

@@ -0,0 +1,74 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationRepository = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("typeorm");
+const scopeType_enum_1 = require("../../domain/enums/scopeType.enum");
+const notification_schema_1 = require("../schema/notification.schema");
+const VISIBLE_TO_USER = `EXISTS (
+  SELECT 1 FROM notification_scopes scope
+  WHERE scope.notification_id = notification.id
+    AND scope.deleted_at IS NULL
+    AND (
+      (scope.scope_type = :userScope AND scope.scope_key = :userId)
+      OR (scope.scope_type = :roleScope AND scope.scope_key IN (:...roleNames))
+      OR scope.scope_type = :allScope
+    )
+)`;
+const NO_ROLES = ["-"];
+let NotificationRepository = class NotificationRepository extends typeorm_1.Repository {
+    constructor(dataSource) {
+        super(notification_schema_1.Notification, dataSource.createEntityManager());
+    }
+    async findVisibleToUser(params, page, limit) {
+        return await this.baseVisibleQuery(params)
+            .orderBy("notification.createdAt", "DESC")
+            .skip((page - 1) * limit)
+            .take(limit)
+            .getManyAndCount();
+    }
+    async countUnread(params) {
+        return await this.baseVisibleQuery(params)
+            .andWhere("read.notification_id IS NULL")
+            .getCount();
+    }
+    async isVisibleToUser(notificationId, params) {
+        const count = await this.baseVisibleQuery(params)
+            .andWhere("notification.id = :notificationId", { notificationId })
+            .getCount();
+        return count > 0;
+    }
+    async findUnreadIds(params) {
+        const rows = await this.baseVisibleQuery(params)
+            .andWhere("read.notification_id IS NULL")
+            .select("notification.id", "id")
+            .getRawMany();
+        return rows.map((row) => row.id);
+    }
+    baseVisibleQuery(params) {
+        return this.createQueryBuilder("notification")
+            .leftJoinAndSelect("notification.reads", "read", "read.user_id = :userId", { userId: params.userId })
+            .where("notification.deletedAt IS NULL")
+            .andWhere(VISIBLE_TO_USER, {
+            userScope: scopeType_enum_1.ScopeType.USER,
+            roleScope: scopeType_enum_1.ScopeType.ROLE,
+            allScope: scopeType_enum_1.ScopeType.ALL,
+            userId: params.userId,
+            roleNames: params.roleNames.length > 0 ? params.roleNames : NO_ROLES,
+        });
+    }
+};
+exports.NotificationRepository = NotificationRepository;
+exports.NotificationRepository = NotificationRepository = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [typeorm_1.DataSource])
+], NotificationRepository);

package/dist/features/notifications/infra/repositories/notificationRead.repository.d.ts

@@ -0,0 +1,6 @@
+import { DataSource, Repository } from "typeorm";
+import { NotificationRead } from "../schema/notificationRead.schema";
+export declare class NotificationReadRepository extends Repository<NotificationRead> {
+    constructor(dataSource: DataSource);
+    markAsRead(notificationIds: string[], userId: string): Promise<void>;
+}

package/dist/features/notifications/infra/repositories/notificationRead.repository.js

@@ -0,0 +1,40 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationReadRepository = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("typeorm");
+const notificationRead_schema_1 = require("../schema/notificationRead.schema");
+let NotificationReadRepository = class NotificationReadRepository extends typeorm_1.Repository {
+    constructor(dataSource) {
+        super(notificationRead_schema_1.NotificationRead, dataSource.createEntityManager());
+    }
+    async markAsRead(notificationIds, userId) {
+        if (notificationIds.length === 0) {
+            return;
+        }
+        await this.createQueryBuilder()
+            .insert()
+            .into(notificationRead_schema_1.NotificationRead)
+            .values(notificationIds.map((notificationId) => ({
+            notificationId,
+            userId,
+            readAt: new Date(),
+        })))
+            .orIgnore()
+            .execute();
+    }
+};
+exports.NotificationReadRepository = NotificationReadRepository;
+exports.NotificationReadRepository = NotificationReadRepository = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [typeorm_1.DataSource])
+], NotificationReadRepository);