rl-core-api 0.1.0

package/dist/core/database/migrations/1786233600000-Notifications.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Notifications1786233600000 = void 0;
+class Notifications1786233600000 {
+    constructor() {
+        this.name = "Notifications1786233600000";
+    }
+    async up(queryRunner) {
+        const ts = `
+      created_at datetime(6) NOT NULL DEFAULT CURRENT_TIMESTAMP(6),
+      updated_at datetime(6) NOT NULL DEFAULT CURRENT_TIMESTAMP(6) ON UPDATE CURRENT_TIMESTAMP(6),
+      deleted_at datetime(6) NULL
+    `;
+        await queryRunner.query(`
+      CREATE TABLE notifications (
+        id char(36) NOT NULL,
+        title varchar(255) NOT NULL,
+        body text NOT NULL,
+        payload json NULL,
+        type enum('INFO','SUCCESS','WARNING','ERROR') NOT NULL,
+        created_by char(36) NULL,
+        ${ts},
+        PRIMARY KEY (id),
+        KEY IDX_notifications_created_at (created_at)
+      ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
+    `);
+        await queryRunner.query(`
+      CREATE TABLE notification_scopes (
+        id char(36) NOT NULL,
+        notification_id char(36) NOT NULL,
+        scope_type enum('USER','ROLE','ALL') NOT NULL,
+        scope_key varchar(100) NULL,
+        ${ts},
+        PRIMARY KEY (id),
+        KEY IDX_notification_scopes_notification (notification_id),
+        KEY IDX_notification_scopes_target (scope_type, scope_key),
+        CONSTRAINT FK_notification_scopes_notification
+          FOREIGN KEY (notification_id) REFERENCES notifications (id) ON DELETE CASCADE
+      ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
+    `);
+        await queryRunner.query(`
+      CREATE TABLE notification_reads (
+        notification_id char(36) NOT NULL,
+        user_id char(36) NOT NULL,
+        read_at datetime NOT NULL,
+        PRIMARY KEY (notification_id, user_id),
+        KEY IDX_notification_reads_user (user_id),
+        CONSTRAINT FK_notification_reads_notification
+          FOREIGN KEY (notification_id) REFERENCES notifications (id) ON DELETE CASCADE
+      ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
+    `);
+    }
+    async down(queryRunner) {
+        await queryRunner.query(`DROP TABLE notification_reads`);
+        await queryRunner.query(`DROP TABLE notification_scopes`);
+        await queryRunner.query(`DROP TABLE notifications`);
+    }
+}
+exports.Notifications1786233600000 = Notifications1786233600000;

package/dist/core/database/migrations/index.d.ts

@@ -0,0 +1,3 @@
+import { MigrationInterface } from "typeorm";
+export type MigrationClass = new () => MigrationInterface;
+export declare const coreMigrations: MigrationClass[];

package/dist/core/database/migrations/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.coreMigrations = void 0;
+const _1710000000000_InitialSchema_1 = require("./1710000000000-InitialSchema");
+const _1786060800000_FirstAccessTokenType_1 = require("./1786060800000-FirstAccessTokenType");
+const _1786147200000_PermanentAccountLock_1 = require("./1786147200000-PermanentAccountLock");
+const _1786233600000_Notifications_1 = require("./1786233600000-Notifications");
+exports.coreMigrations = [
+    _1710000000000_InitialSchema_1.InitialSchema1710000000000,
+    _1786060800000_FirstAccessTokenType_1.FirstAccessTokenType1786060800000,
+    _1786147200000_PermanentAccountLock_1.PermanentAccountLock1786147200000,
+    _1786233600000_Notifications_1.Notifications1786233600000,
+];

package/dist/core/database/seeds/runSeeds.d.ts

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

package/dist/core/database/seeds/runSeeds.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const seedAdmin_1 = require("./seedAdmin");
+const seedPermissions_1 = require("./seedPermissions");
+const dataSource_1 = require("../../../dataSource");
+async function run() {
+    await dataSource_1.AppDataSource.initialize();
+    try {
+        await (0, seedPermissions_1.seedPermissions)(dataSource_1.AppDataSource);
+        await (0, seedAdmin_1.seedAdmin)(dataSource_1.AppDataSource);
+        console.log("[seed] Concluído com sucesso.");
+    }
+    finally {
+        await dataSource_1.AppDataSource.destroy();
+    }
+}
+run().catch((err) => {
+    console.error("[seed] Falhou:", err);
+    process.exit(1);
+});

package/dist/core/database/seeds/seedAdmin.d.ts

@@ -0,0 +1,2 @@
+import { DataSource } from "typeorm";
+export declare function seedAdmin(ds: DataSource): Promise<void>;

package/dist/core/database/seeds/seedAdmin.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.seedAdmin = seedAdmin;
+const hash_util_1 = require("../../utils/hash.util");
+const role_schema_1 = require("../../../features/rbac/infra/schema/role.schema");
+const user_schema_1 = require("../../../features/users/infra/schema/user.schema");
+async function seedAdmin(ds) {
+    const userRepo = ds.getRepository(user_schema_1.User);
+    const roleRepo = ds.getRepository(role_schema_1.Role);
+    const email = process.env.SEED_ADMIN_EMAIL;
+    const password = process.env.SEED_ADMIN_PASSWORD;
+    const name = process.env.SEED_ADMIN_NAME ?? "Administrador";
+    if (!email || !password) {
+        throw new Error("SEED_ADMIN_EMAIL e SEED_ADMIN_PASSWORD são obrigatórios para rodar o seed do admin (sem valor padrão, por segurança).");
+    }
+    const existing = await userRepo.findOne({
+        where: { email },
+        relations: { roles: true },
+        withDeleted: true,
+    });
+    const superAdmin = await roleRepo.findOne({ where: { name: "Super Admin" } });
+    if (!superAdmin) {
+        throw new Error('Role "Super Admin" não encontrada — rode seedPermissions antes.');
+    }
+    if (existing) {
+        if (!existing.roles?.some((r) => r.id === superAdmin.id)) {
+            existing.roles = [...(existing.roles ?? []), superAdmin];
+            await userRepo.save(existing);
+        }
+        console.log(`[seed] Admin já existe: ${email}`);
+        return;
+    }
+    const admin = userRepo.create({
+        name,
+        email,
+        password: await (0, hash_util_1.hashPassword)(password),
+        passwordChangedAt: new Date(),
+        mustChangePassword: true,
+        isActive: true,
+        roles: [superAdmin],
+    });
+    await userRepo.save(admin);
+    console.log(`[seed] Admin criado: ${email} — defina a senha via SEED_ADMIN_PASSWORD e troque após o 1º acesso!`);
+}

package/dist/core/database/seeds/seedPermissions.d.ts

@@ -0,0 +1,2 @@
+import { DataSource } from "typeorm";
+export declare function seedPermissions(ds: DataSource): Promise<void>;

package/dist/core/database/seeds/seedPermissions.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.seedPermissions = seedPermissions;
+const rbac_catalog_1 = require("../../../features/rbac/domain/rbac.catalog");
+const action_schema_1 = require("../../../features/rbac/infra/schema/action.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");
+async function seedPermissions(ds) {
+    const resourceRepo = ds.getRepository(resource_schema_1.Resource);
+    const actionRepo = ds.getRepository(action_schema_1.Action);
+    const scopeRepo = ds.getRepository(scope_schema_1.Scope);
+    const permissionRepo = ds.getRepository(permission_schema_1.Permission);
+    const roleRepo = ds.getRepository(role_schema_1.Role);
+    const resources = new Map();
+    for (const r of rbac_catalog_1.RESOURCES) {
+        let entity = await resourceRepo.findOne({
+            where: { name: r.name },
+            withDeleted: true,
+        });
+        if (!entity) {
+            entity = await resourceRepo.save(resourceRepo.create(r));
+        }
+        resources.set(r.name, entity);
+    }
+    const actions = new Map();
+    for (const a of rbac_catalog_1.ACTIONS) {
+        let entity = await actionRepo.findOne({
+            where: { name: a.name },
+            withDeleted: true,
+        });
+        if (!entity) {
+            entity = await actionRepo.save(actionRepo.create(a));
+        }
+        actions.set(a.name, entity);
+    }
+    const scopes = new Map();
+    for (const s of rbac_catalog_1.SCOPES) {
+        let entity = await scopeRepo.findOne({
+            where: { name: s.name },
+            withDeleted: true,
+        });
+        if (!entity) {
+            entity = await scopeRepo.save(scopeRepo.create(s));
+        }
+        scopes.set(s.name, entity);
+    }
+    const permissions = new Map();
+    for (const p of rbac_catalog_1.PERMISSIONS) {
+        let entity = await permissionRepo.findOne({
+            where: { code: p.code },
+            withDeleted: true,
+        });
+        if (!entity) {
+            const [resourceName, actionName, scopeName] = p.code.split(":");
+            const resource = resources.get(resourceName);
+            const action = actions.get(actionName);
+            const scope = scopes.get(scopeName);
+            if (!resource || !action || !scope) {
+                throw new Error(`Permissão ${p.code} referencia resource/action/scope inexistente`);
+            }
+            entity = await permissionRepo.save(permissionRepo.create({
+                code: p.code,
+                description: p.description,
+                resourceId: resource.id,
+                actionId: action.id,
+                scopeId: scope.id,
+            }));
+        }
+        permissions.set(p.code, entity);
+    }
+    for (const r of rbac_catalog_1.ROLES) {
+        let role = await roleRepo.findOne({
+            where: { name: r.name },
+            relations: { permissions: true },
+            withDeleted: true,
+        });
+        if (!role) {
+            role = roleRepo.create({
+                name: r.name,
+                description: r.description,
+                permissions: [],
+            });
+        }
+        const codes = r.permissions === "*" ? rbac_catalog_1.PERMISSIONS.map((p) => p.code) : r.permissions;
+        role.permissions = codes
+            .map((code) => permissions.get(code))
+            .filter(Boolean);
+        await roleRepo.save(role);
+    }
+    console.log(`[seed] RBAC: ${resources.size} resources, ${actions.size} actions, ${scopes.size} scopes, ${permissions.size} permissions, ${rbac_catalog_1.ROLES.length} roles`);
+}

package/dist/core/events/appEvent.enum.d.ts

@@ -0,0 +1,31 @@
+export declare enum AppEvent {
+    USER_LOCKED = "user.locked",
+    USER_TWO_FACTOR_RESET = "user.two-factor-reset",
+    USER_ROLES_CHANGED = "user.roles-changed",
+    USER_PASSWORD_RESET_REQUESTED = "user.password-reset-requested",
+    USER_PASSWORD_EXPIRING = "user.password-expiring",
+    SYSTEM_CLEANUP_FAILED = "system.cleanup-failed"
+}
+export interface UserLockedEvent {
+    userId: string;
+    userName: string;
+    userEmail: string;
+}
+export interface UserTwoFactorResetEvent {
+    userId: string;
+}
+export interface UserRolesChangedEvent {
+    userId: string;
+    roleNames: string[];
+}
+export interface UserPasswordResetRequestedEvent {
+    userId: string;
+}
+export interface UserPasswordExpiringEvent {
+    userId: string;
+    daysLeft: number;
+}
+export interface SystemCleanupFailedEvent {
+    routine: string;
+    reason: string;
+}

package/dist/core/events/appEvent.enum.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppEvent = void 0;
+var AppEvent;
+(function (AppEvent) {
+    AppEvent["USER_LOCKED"] = "user.locked";
+    AppEvent["USER_TWO_FACTOR_RESET"] = "user.two-factor-reset";
+    AppEvent["USER_ROLES_CHANGED"] = "user.roles-changed";
+    AppEvent["USER_PASSWORD_RESET_REQUESTED"] = "user.password-reset-requested";
+    AppEvent["USER_PASSWORD_EXPIRING"] = "user.password-expiring";
+    AppEvent["SYSTEM_CLEANUP_FAILED"] = "system.cleanup-failed";
+})(AppEvent || (exports.AppEvent = AppEvent = {}));

package/dist/core/filters/allExceptions.filter.d.ts

@@ -0,0 +1,5 @@
+import { ArgumentsHost, ExceptionFilter } from "@nestjs/common";
+export declare class AllExceptionsFilter implements ExceptionFilter {
+    private readonly logger;
+    catch(exception: unknown, host: ArgumentsHost): void;
+}

package/dist/core/filters/allExceptions.filter.js

@@ -0,0 +1,61 @@
+"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.AllExceptionsFilter = void 0;
+const common_1 = require("@nestjs/common");
+let AllExceptionsFilter = class AllExceptionsFilter {
+    constructor() {
+        this.logger = new common_1.Logger("Exception");
+    }
+    catch(exception, host) {
+        const ctx = host.switchToHttp();
+        const response = ctx.getResponse();
+        const request = ctx.getRequest();
+        const requestId = request.requestId ?? null;
+        const isHttp = exception instanceof common_1.HttpException;
+        const status = isHttp
+            ? exception.getStatus()
+            : common_1.HttpStatus.INTERNAL_SERVER_ERROR;
+        let message = "Erro interno do servidor";
+        let error = "InternalServerError";
+        let errorCode = null;
+        if (isHttp) {
+            const res = exception.getResponse();
+            if (typeof res === "string") {
+                message = res;
+            }
+            else if (typeof res === "object" && res !== null) {
+                const body = res;
+                message = body.message ?? res;
+                error = body.error ?? exception.name;
+                errorCode = body.errorCode ?? null;
+            }
+        }
+        else if (exception instanceof Error) {
+            if (process.env.NODE_ENV === "production") {
+                this.logger.error(`[${requestId}] ${request.method} ${request.url} - ${exception.message}`);
+            }
+            else {
+                this.logger.error(`[${requestId}] ${exception.message}`, exception.stack);
+            }
+        }
+        response.status(status).json({
+            statusCode: status,
+            message,
+            error,
+            errorCode,
+            path: request.url,
+            timestamp: new Date().toISOString(),
+            requestId,
+        });
+    }
+};
+exports.AllExceptionsFilter = AllExceptionsFilter;
+exports.AllExceptionsFilter = AllExceptionsFilter = __decorate([
+    (0, common_1.Catch)()
+], AllExceptionsFilter);

package/dist/core/filters/appErrorCode.enum.d.ts

@@ -0,0 +1,9 @@
+export declare enum AppErrorCode {
+    ACCOUNT_LOCKED = "ACCOUNT_LOCKED",
+    ACCOUNT_INACTIVE = "ACCOUNT_INACTIVE",
+    INVALID_CREDENTIALS = "INVALID_CREDENTIALS",
+    INVALID_TWO_FACTOR_CODE = "INVALID_TWO_FACTOR_CODE",
+    PASSWORD_REUSED = "PASSWORD_REUSED",
+    TOO_MANY_REQUESTS = "TOO_MANY_REQUESTS",
+    INVALID_FILTER = "INVALID_FILTER"
+}

package/dist/core/filters/appErrorCode.enum.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppErrorCode = void 0;
+var AppErrorCode;
+(function (AppErrorCode) {
+    AppErrorCode["ACCOUNT_LOCKED"] = "ACCOUNT_LOCKED";
+    AppErrorCode["ACCOUNT_INACTIVE"] = "ACCOUNT_INACTIVE";
+    AppErrorCode["INVALID_CREDENTIALS"] = "INVALID_CREDENTIALS";
+    AppErrorCode["INVALID_TWO_FACTOR_CODE"] = "INVALID_TWO_FACTOR_CODE";
+    AppErrorCode["PASSWORD_REUSED"] = "PASSWORD_REUSED";
+    AppErrorCode["TOO_MANY_REQUESTS"] = "TOO_MANY_REQUESTS";
+    AppErrorCode["INVALID_FILTER"] = "INVALID_FILTER";
+})(AppErrorCode || (exports.AppErrorCode = AppErrorCode = {}));

package/dist/core/health/health.controller.d.ts

@@ -0,0 +1,11 @@
+import { DataSource } from "typeorm";
+export declare class HealthController {
+    private readonly ds;
+    private readonly logger;
+    constructor(ds: DataSource);
+    check(): Promise<{
+        status: string;
+        database: string;
+        timestamp: string;
+    }>;
+}

package/dist/core/health/health.controller.js

@@ -0,0 +1,56 @@
+"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 HealthController_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HealthController = void 0;
+const common_1 = require("@nestjs/common");
+const swagger_1 = require("@nestjs/swagger");
+const typeorm_1 = require("@nestjs/typeorm");
+const typeorm_2 = require("typeorm");
+const public_decorator_1 = require("../auth/decorators/public.decorator");
+let HealthController = HealthController_1 = class HealthController {
+    constructor(ds) {
+        this.ds = ds;
+        this.logger = new common_1.Logger(HealthController_1.name);
+    }
+    async check() {
+        let database = "up";
+        try {
+            await this.ds.query("SELECT 1");
+        }
+        catch (err) {
+            this.logger.error(`Healthcheck do banco falhou: ${err.message}`);
+            database = "down";
+        }
+        return {
+            status: database === "up" ? "ok" : "degraded",
+            database,
+            timestamp: new Date().toISOString(),
+        };
+    }
+};
+exports.HealthController = HealthController;
+__decorate([
+    (0, public_decorator_1.Public)(),
+    (0, common_1.Get)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], HealthController.prototype, "check", null);
+exports.HealthController = HealthController = HealthController_1 = __decorate([
+    (0, swagger_1.ApiTags)("Health"),
+    (0, common_1.Controller)({ path: "health", version: "1" }),
+    __param(0, (0, typeorm_1.InjectDataSource)()),
+    __metadata("design:paramtypes", [typeorm_2.DataSource])
+], HealthController);

package/dist/core/logger/winston.config.d.ts

@@ -0,0 +1,2 @@
+import { LoggerService } from "@nestjs/common";
+export declare function createAppLogger(): LoggerService;

package/dist/core/logger/winston.config.js

@@ -0,0 +1,74 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAppLogger = createAppLogger;
+const nest_winston_1 = require("nest-winston");
+const winston = __importStar(require("winston"));
+function text(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    if (typeof value === "number" || typeof value === "boolean") {
+        return String(value);
+    }
+    return "";
+}
+function createAppLogger() {
+    const isProd = process.env.NODE_ENV === "production";
+    return nest_winston_1.WinstonModule.createLogger({
+        level: process.env.LOG_LEVEL ?? "info",
+        transports: [
+            new winston.transports.Console({
+                format: isProd
+                    ? winston.format.combine(winston.format.timestamp(), winston.format.json())
+                    : winston.format.combine(winston.format.timestamp(), winston.format.ms(), winston.format.colorize(), winston.format.printf((info) => {
+                        const timestamp = text(info.timestamp);
+                        const context = info.context ? `[${text(info.context)}] ` : "";
+                        const ms = text(info.ms);
+                        return `${timestamp} ${info.level} ${context}${text(info.message)} ${ms}`;
+                    })),
+            }),
+            new winston.transports.File({
+                filename: "logs/error.log",
+                level: "error",
+                format: winston.format.combine(winston.format.timestamp(), winston.format.json()),
+            }),
+            new winston.transports.File({
+                filename: "logs/combined.log",
+                format: winston.format.combine(winston.format.timestamp(), winston.format.json()),
+            }),
+        ],
+    });
+}

package/dist/core/mailer/mailer.module.d.ts

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

package/dist/core/mailer/mailer.module.js

@@ -0,0 +1,21 @@
+"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.MailerModule = void 0;
+const common_1 = require("@nestjs/common");
+const mailer_service_1 = require("./mailer.service");
+let MailerModule = class MailerModule {
+};
+exports.MailerModule = MailerModule;
+exports.MailerModule = MailerModule = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({
+        providers: [mailer_service_1.MailerService],
+        exports: [mailer_service_1.MailerService],
+    })
+], MailerModule);

package/dist/core/mailer/mailer.service.d.ts

@@ -0,0 +1,14 @@
+import { EnvService } from "../config/env.service";
+export declare class MailerService {
+    private readonly env;
+    private readonly logger;
+    private readonly transporter;
+    constructor(env: EnvService);
+    private send;
+    private escapeHtml;
+    private layout;
+    sendTwoFactorCode(to: string, code: string, userName: string): Promise<void>;
+    sendPasswordReset(to: string, token: string, userName: string): Promise<void>;
+    private formatExpiry;
+    sendFirstAccess(to: string, token: string, userName: string): Promise<void>;
+}