@flusys/nestjs-email 7.0.2 → 8.0.0-beta.1

package/fesm/controllers/email-config.controller.js

@@ -1,101 +0,0 @@
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function _ts_decorate(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;
-}
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-function _ts_param(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
-}
-import { createApiController, EMAIL_CONFIG_PERMISSIONS } from '@flusys/nestjs-shared/classes';
-import { Controller, Inject } from '@nestjs/common';
-import { ApiTags } from '@nestjs/swagger';
-import { CreateEmailConfigDto, EmailConfigResponseDto, UpdateEmailConfigDto } from '../dtos';
-import { EmailProviderConfigService } from '../services';
-export class EmailConfigController extends createApiController(CreateEmailConfigDto, UpdateEmailConfigDto, EmailConfigResponseDto, {
-    entityName: 'email.config',
-    security: {
-        insert: {
-            level: 'permission',
-            permissions: [
-                EMAIL_CONFIG_PERMISSIONS.CREATE
-            ]
-        },
-        insertMany: {
-            level: 'permission',
-            permissions: [
-                EMAIL_CONFIG_PERMISSIONS.CREATE
-            ]
-        },
-        getById: {
-            level: 'permission',
-            permissions: [
-                EMAIL_CONFIG_PERMISSIONS.READ
-            ]
-        },
-        getAll: {
-            level: 'permission',
-            permissions: [
-                EMAIL_CONFIG_PERMISSIONS.READ
-            ]
-        },
-        update: {
-            level: 'permission',
-            permissions: [
-                EMAIL_CONFIG_PERMISSIONS.UPDATE
-            ]
-        },
-        updateMany: {
-            level: 'permission',
-            permissions: [
-                EMAIL_CONFIG_PERMISSIONS.UPDATE
-            ]
-        },
-        delete: {
-            level: 'permission',
-            permissions: [
-                EMAIL_CONFIG_PERMISSIONS.DELETE
-            ]
-        }
-    },
-    enabledEndpoints: [
-        'insert',
-        'insertMany',
-        'getById',
-        'getAll',
-        'update',
-        'updateMany',
-        'delete'
-    ]
-}) {
-    constructor(emailConfigService){
-        super(emailConfigService), _define_property(this, "emailConfigService", void 0), this.emailConfigService = emailConfigService;
-    }
-}
-EmailConfigController = _ts_decorate([
-    ApiTags('Email Config'),
-    Controller('email/email-config'),
-    _ts_param(0, Inject(EmailProviderConfigService)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof EmailProviderConfigService === "undefined" ? Object : EmailProviderConfigService
-    ])
-], EmailConfigController);

package/fesm/controllers/email-config.controller.spec.js

@@ -1,81 +0,0 @@
-import { buildMockUser } from '@test-utils/mocks/logged-user.mock';
-import { EmailConfigController } from './email-config.controller';
-function buildEmailConfig(overrides = {}) {
-    return {
-        id: 'email-config-1',
-        provider: 'smtp',
-        isActive: true,
-        isDefault: true,
-        readOnly: false,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        ...overrides
-    };
-}
-describe('EmailConfigController', ()=>{
-    let controller;
-    let mockEmailConfigService;
-    beforeEach(()=>{
-        mockEmailConfigService = {
-            insert: jest.fn(),
-            findById: jest.fn(),
-            getAll: jest.fn(),
-            update: jest.fn(),
-            delete: jest.fn()
-        };
-        controller = new EmailConfigController(mockEmailConfigService);
-    });
-    it('wires the injected service onto the generated controller base', ()=>{
-        expect(controller.emailConfigService).toBe(mockEmailConfigService);
-        expect(controller.service).toBe(mockEmailConfigService);
-    });
-    describe('insert', ()=>{
-        it('creates an email config and returns the mapped response', async ()=>{
-            const user = buildMockUser();
-            mockEmailConfigService.insert.mockResolvedValue(buildEmailConfig());
-            const result = await controller.insert({
-                provider: 'smtp'
-            }, user);
-            expect(mockEmailConfigService.insert).toHaveBeenCalledWith({
-                provider: 'smtp'
-            }, user);
-            expect(result.success).toBe(true);
-            expect(result.data).toEqual(expect.objectContaining({
-                id: 'email-config-1'
-            }));
-        });
-    });
-    describe('getAll', ()=>{
-        it('paginates email configs and maps the response list', async ()=>{
-            mockEmailConfigService.getAll.mockResolvedValue({
-                data: [
-                    buildEmailConfig()
-                ],
-                total: 1
-            });
-            const result = await controller.getAll({}, buildMockUser(), '');
-            expect(mockEmailConfigService.getAll).toHaveBeenCalledWith('', {}, buildMockUser());
-            expect(result.data).toHaveLength(1);
-        });
-    });
-    describe('delete', ()=>{
-        it('delegates soft-delete to the service', async ()=>{
-            mockEmailConfigService.delete.mockResolvedValue({
-                count: 1
-            });
-            const result = await controller.delete({
-                id: [
-                    'email-config-1'
-                ],
-                type: 'delete'
-            }, buildMockUser());
-            expect(mockEmailConfigService.delete).toHaveBeenCalledWith({
-                id: [
-                    'email-config-1'
-                ],
-                type: 'delete'
-            }, buildMockUser());
-            expect(result.success).toBe(true);
-        });
-    });
-});

package/fesm/controllers/email-send.controller.js

@@ -1,118 +0,0 @@
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function _ts_decorate(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;
-}
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-function _ts_param(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
-}
-import { CurrentUser } from '@flusys/nestjs-shared/decorators';
-import { JwtAuthGuard } from '@flusys/nestjs-shared/guards';
-import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
-import { Body, Controller, Inject, Post, UseGuards } from '@nestjs/common';
-import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
-import { EMAIL_SEND_MESSAGES } from '../config';
-import { SendEmailDto, SendTemplateEmailDto, TestEmailDto } from '../dtos';
-import { EmailSendService } from '../services';
-export class EmailSendController {
-    async sendEmail(dto, user) {
-        const result = await this.emailSendService.sendEmail(dto, user);
-        return this.toResponse(result, 'Email');
-    }
-    async sendTemplateEmail(dto, user) {
-        const result = await this.emailSendService.sendTemplateEmail(dto, user);
-        return this.toResponse(result, 'Template email');
-    }
-    async sendTestEmail(dto, user) {
-        const result = await this.emailSendService.sendTestEmail(dto.emailConfigId, dto.recipient, user);
-        return this.toResponse(result, 'Test email');
-    }
-    toResponse(result, label) {
-        return {
-            success: result.success,
-            message: result.success ? `${label} sent successfully` : `Failed to send ${label.toLowerCase()}`,
-            messageKey: result.success ? EMAIL_SEND_MESSAGES.SUCCESS : EMAIL_SEND_MESSAGES.FAILED,
-            data: {
-                success: result.success,
-                messageId: result.messageId,
-                error: result.error
-            }
-        };
-    }
-    constructor(emailSendService){
-        _define_property(this, "emailSendService", void 0);
-        this.emailSendService = emailSendService;
-    }
-}
-_ts_decorate([
-    Post('direct'),
-    ApiOperation({
-        summary: 'Send email directly with custom content'
-    }),
-    _ts_param(0, Body()),
-    _ts_param(1, CurrentUser()),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof SendEmailDto === "undefined" ? Object : SendEmailDto,
-        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], EmailSendController.prototype, "sendEmail", null);
-_ts_decorate([
-    Post('template'),
-    ApiOperation({
-        summary: 'Send email using a template with variable interpolation'
-    }),
-    _ts_param(0, Body()),
-    _ts_param(1, CurrentUser()),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof SendTemplateEmailDto === "undefined" ? Object : SendTemplateEmailDto,
-        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], EmailSendController.prototype, "sendTemplateEmail", null);
-_ts_decorate([
-    Post('test'),
-    ApiOperation({
-        summary: 'Send a test email to verify configuration'
-    }),
-    _ts_param(0, Body()),
-    _ts_param(1, CurrentUser()),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof TestEmailDto === "undefined" ? Object : TestEmailDto,
-        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], EmailSendController.prototype, "sendTestEmail", null);
-EmailSendController = _ts_decorate([
-    ApiTags('Email Send'),
-    ApiBearerAuth(),
-    Controller('email/send'),
-    UseGuards(JwtAuthGuard),
-    _ts_param(0, Inject(EmailSendService)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof EmailSendService === "undefined" ? Object : EmailSendService
-    ])
-], EmailSendController);

package/fesm/controllers/email-send.controller.spec.js

@@ -1,135 +0,0 @@
-import { Test } from '@nestjs/testing';
-import { buildMockUser } from '@test-utils/mocks/logged-user.mock';
-import { EmailSendController } from './email-send.controller';
-import { EmailSendService } from '../services';
-describe('EmailSendController', ()=>{
-    let controller;
-    let mockService;
-    beforeEach(async ()=>{
-        mockService = {
-            sendEmail: jest.fn(),
-            sendTemplateEmail: jest.fn(),
-            sendTestEmail: jest.fn()
-        };
-        const module = await Test.createTestingModule({
-            controllers: [
-                EmailSendController
-            ],
-            providers: [
-                {
-                    provide: EmailSendService,
-                    useValue: mockService
-                }
-            ]
-        }).compile();
-        controller = module.get(EmailSendController);
-    });
-    describe('sendEmail', ()=>{
-        it('delegates to the service and returns a success response', async ()=>{
-            mockService.sendEmail.mockResolvedValue({
-                success: true,
-                messageId: 'msg-1'
-            });
-            const dto = {
-                to: 'a@example.com',
-                subject: 'Hi',
-                html: '<p/>'
-            };
-            const user = buildMockUser();
-            const result = await controller.sendEmail(dto, user);
-            expect(mockService.sendEmail).toHaveBeenCalledWith(dto, user);
-            expect(result).toEqual({
-                success: true,
-                message: 'Email sent successfully',
-                messageKey: 'email.send.success',
-                data: {
-                    success: true,
-                    messageId: 'msg-1',
-                    error: undefined
-                }
-            });
-        });
-        it('returns a failure response with the FAILED messageKey when the send fails', async ()=>{
-            mockService.sendEmail.mockResolvedValue({
-                success: false,
-                error: 'SMTP down'
-            });
-            const result = await controller.sendEmail({
-                to: 'a@example.com',
-                subject: 'Hi',
-                html: '<p/>'
-            }, buildMockUser());
-            expect(result).toEqual({
-                success: false,
-                message: 'Failed to send email',
-                messageKey: 'email.send.failed',
-                data: {
-                    success: false,
-                    messageId: undefined,
-                    error: 'SMTP down'
-                }
-            });
-        });
-    });
-    describe('sendTemplateEmail', ()=>{
-        it('delegates to the service and returns a success response', async ()=>{
-            mockService.sendTemplateEmail.mockResolvedValue({
-                success: true,
-                messageId: 'msg-2'
-            });
-            const dto = {
-                to: 'a@example.com',
-                templateSlug: 'welcome'
-            };
-            const user = buildMockUser();
-            const result = await controller.sendTemplateEmail(dto, user);
-            expect(mockService.sendTemplateEmail).toHaveBeenCalledWith(dto, user);
-            expect(result.success).toBe(true);
-            expect(result.messageKey).toBe('email.send.success');
-            expect(result.message).toBe('Template email sent successfully');
-        });
-        it('returns a failure response when the template send fails', async ()=>{
-            mockService.sendTemplateEmail.mockResolvedValue({
-                success: false,
-                error: 'Template error'
-            });
-            const result = await controller.sendTemplateEmail({
-                to: 'a@example.com',
-                templateSlug: 'welcome'
-            }, buildMockUser());
-            expect(result.success).toBe(false);
-            expect(result.messageKey).toBe('email.send.failed');
-            expect(result.message).toBe('Failed to send template email');
-        });
-    });
-    describe('sendTestEmail', ()=>{
-        it('delegates to the service with the emailConfigId and recipient from the dto', async ()=>{
-            mockService.sendTestEmail.mockResolvedValue({
-                success: true,
-                messageId: 'msg-3'
-            });
-            const dto = {
-                emailConfigId: 'config-1',
-                recipient: 'a@example.com'
-            };
-            const user = buildMockUser();
-            const result = await controller.sendTestEmail(dto, user);
-            expect(mockService.sendTestEmail).toHaveBeenCalledWith('config-1', 'a@example.com', user);
-            expect(result.success).toBe(true);
-            expect(result.message).toBe('Test email sent successfully');
-        });
-        it('returns a failure response when the test send fails', async ()=>{
-            mockService.sendTestEmail.mockResolvedValue({
-                success: false,
-                error: 'Bad config'
-            });
-            const result = await controller.sendTestEmail({
-                emailConfigId: 'config-1',
-                recipient: 'a@example.com'
-            }, buildMockUser());
-            expect(result.success).toBe(false);
-            expect(result.message).toBe('Failed to send test email');
-            expect(result.messageKey).toBe('email.send.failed');
-        });
-    });
-});

package/fesm/controllers/email-template.controller.js

@@ -1,132 +0,0 @@
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function _ts_decorate(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;
-}
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-function _ts_param(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
-}
-import { createApiController, EMAIL_TEMPLATE_PERMISSIONS } from '@flusys/nestjs-shared/classes';
-import { CurrentUser, RequirePermission } from '@flusys/nestjs-shared/decorators';
-import { JwtAuthGuard, PermissionGuard } from '@flusys/nestjs-shared/guards';
-import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
-import { Body, Controller, Inject, NotFoundException, Post, UseGuards } from '@nestjs/common';
-import { ApiBearerAuth, ApiOperation, ApiResponse, ApiTags } from '@nestjs/swagger';
-import { EMAIL_TEMPLATE_MESSAGES } from '../config';
-import { CreateEmailTemplateDto, EmailTemplateResponseDto, UpdateEmailTemplateDto } from '../dtos';
-import { EmailTemplateService } from '../services';
-export class EmailTemplateController extends createApiController(CreateEmailTemplateDto, UpdateEmailTemplateDto, EmailTemplateResponseDto, {
-    entityName: 'email.template',
-    security: {
-        insert: {
-            level: 'permission',
-            permissions: [
-                EMAIL_TEMPLATE_PERMISSIONS.CREATE
-            ]
-        },
-        insertMany: {
-            level: 'permission',
-            permissions: [
-                EMAIL_TEMPLATE_PERMISSIONS.CREATE
-            ]
-        },
-        getById: {
-            level: 'permission',
-            permissions: [
-                EMAIL_TEMPLATE_PERMISSIONS.READ
-            ]
-        },
-        getAll: {
-            level: 'permission',
-            permissions: [
-                EMAIL_TEMPLATE_PERMISSIONS.READ
-            ]
-        },
-        update: {
-            level: 'permission',
-            permissions: [
-                EMAIL_TEMPLATE_PERMISSIONS.UPDATE
-            ]
-        },
-        updateMany: {
-            level: 'permission',
-            permissions: [
-                EMAIL_TEMPLATE_PERMISSIONS.UPDATE
-            ]
-        },
-        delete: {
-            level: 'permission',
-            permissions: [
-                EMAIL_TEMPLATE_PERMISSIONS.DELETE
-            ]
-        }
-    }
-}) {
-    async getBySlug(body, user) {
-        const data = await this.emailTemplateService.findBySlug(body.slug, user);
-        if (!data) {
-            throw new NotFoundException({
-                message: 'Email template not found',
-                messageKey: EMAIL_TEMPLATE_MESSAGES.NOT_FOUND
-            });
-        }
-        return {
-            success: true,
-            message: 'Template retrieved',
-            messageKey: EMAIL_TEMPLATE_MESSAGES.GET_SUCCESS,
-            data
-        };
-    }
-    constructor(emailTemplateService){
-        super(emailTemplateService), _define_property(this, "emailTemplateService", void 0), this.emailTemplateService = emailTemplateService;
-    }
-}
-_ts_decorate([
-    Post('get-by-slug'),
-    UseGuards(JwtAuthGuard, PermissionGuard),
-    ApiBearerAuth(),
-    RequirePermission(EMAIL_TEMPLATE_PERMISSIONS.READ),
-    ApiOperation({
-        summary: 'Get email template by slug'
-    }),
-    ApiResponse({
-        status: 200,
-        type: EmailTemplateResponseDto
-    }),
-    _ts_param(0, Body()),
-    _ts_param(1, CurrentUser()),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        Object,
-        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], EmailTemplateController.prototype, "getBySlug", null);
-EmailTemplateController = _ts_decorate([
-    ApiTags('Email Template'),
-    Controller('email/email-template'),
-    _ts_param(0, Inject(EmailTemplateService)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof EmailTemplateService === "undefined" ? Object : EmailTemplateService
-    ])
-], EmailTemplateController);

package/fesm/controllers/email-template.controller.spec.js

@@ -1,85 +0,0 @@
-import { NotFoundException } from '@nestjs/common';
-import { buildMockUser } from '@test-utils/mocks/logged-user.mock';
-import { EmailTemplateController } from './email-template.controller';
-function buildTemplate(overrides = {}) {
-    return {
-        id: 'template-1',
-        slug: 'password-reset',
-        subject: 'Reset your password',
-        body: '<p>Hello {{name}}</p>',
-        isActive: true,
-        readOnly: false,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        ...overrides
-    };
-}
-describe('EmailTemplateController', ()=>{
-    let controller;
-    let mockEmailTemplateService;
-    beforeEach(()=>{
-        mockEmailTemplateService = {
-            insert: jest.fn(),
-            findById: jest.fn(),
-            getAll: jest.fn(),
-            update: jest.fn(),
-            delete: jest.fn(),
-            findBySlug: jest.fn()
-        };
-        controller = new EmailTemplateController(mockEmailTemplateService);
-    });
-    it('wires the injected service onto the generated controller base', ()=>{
-        expect(controller.emailTemplateService).toBe(mockEmailTemplateService);
-        expect(controller.service).toBe(mockEmailTemplateService);
-    });
-    describe('insert', ()=>{
-        it('creates an email template and returns the mapped response', async ()=>{
-            const user = buildMockUser();
-            mockEmailTemplateService.insert.mockResolvedValue(buildTemplate());
-            const result = await controller.insert({
-                slug: 'password-reset'
-            }, user);
-            expect(mockEmailTemplateService.insert).toHaveBeenCalledWith({
-                slug: 'password-reset'
-            }, user);
-            expect(result.success).toBe(true);
-            expect(result.data).toEqual(expect.objectContaining({
-                id: 'template-1'
-            }));
-        });
-    });
-    describe('getAll', ()=>{
-        it('paginates templates and maps the response list', async ()=>{
-            mockEmailTemplateService.getAll.mockResolvedValue({
-                data: [
-                    buildTemplate()
-                ],
-                total: 1
-            });
-            const result = await controller.getAll({}, buildMockUser(), '');
-            expect(mockEmailTemplateService.getAll).toHaveBeenCalledWith('', {}, buildMockUser());
-            expect(result.data).toHaveLength(1);
-        });
-    });
-    describe('getBySlug', ()=>{
-        it('returns the template matching the given slug', async ()=>{
-            const user = buildMockUser();
-            mockEmailTemplateService.findBySlug.mockResolvedValue(buildTemplate());
-            const result = await controller.getBySlug({
-                slug: 'password-reset'
-            }, user);
-            expect(mockEmailTemplateService.findBySlug).toHaveBeenCalledWith('password-reset', user);
-            expect(result.success).toBe(true);
-            expect(result.data).toEqual(expect.objectContaining({
-                slug: 'password-reset'
-            }));
-        });
-        it('throws NotFoundException when no template matches the slug', async ()=>{
-            const user = buildMockUser();
-            mockEmailTemplateService.findBySlug.mockResolvedValue(null);
-            await expect(controller.getBySlug({
-                slug: 'missing'
-            }, user)).rejects.toThrow(NotFoundException);
-        });
-    });
-});