@flusys/nestjs-email 6.0.2 → 6.1.1

package/cjs/services/email-template.service.spec.js

@@ -0,0 +1,257 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _testing = require("@nestjs/testing");
+const _modules = require("@flusys/nestjs-shared/modules");
+const _repositorymock = require("@test-utils/mocks/repository.mock");
+const _loggedusermock = require("@test-utils/mocks/logged-user.mock");
+const _entities = require("../entities");
+const _emailconfigservice = require("./email-config.service");
+const _emaildatasourceprovider = require("./email-datasource.provider");
+const _emailtemplateservice = require("./email-template.service");
+function buildTemplate(overrides = {}) {
+    return {
+        id: 'template-uuid-1',
+        name: 'Welcome Email',
+        slug: 'welcome-email',
+        description: null,
+        subject: 'Welcome {{firstName}}!',
+        schema: {
+            fields: []
+        },
+        htmlContent: '<h1>Welcome {{firstName}}!</h1>',
+        textContent: 'Welcome {{firstName}}!',
+        schemaVersion: 1,
+        isActive: true,
+        isHtml: true,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        deletedAt: null,
+        createdById: null,
+        updatedById: null,
+        deletedById: null,
+        ...overrides
+    };
+}
+function buildQuery() {
+    return {
+        select: jest.fn().mockReturnThis(),
+        andWhere: jest.fn().mockReturnThis(),
+        orderBy: jest.fn().mockReturnThis()
+    };
+}
+describe('EmailTemplateService', ()=>{
+    let service;
+    let mockRepo;
+    let mockEmailConfig;
+    beforeEach(async ()=>{
+        mockRepo = (0, _repositorymock.createMockRepository)();
+        const mockDataSourceProvider = (0, _repositorymock.createMockDataSourceProvider)(mockRepo);
+        mockEmailConfig = {
+            isCompanyFeatureEnabled: jest.fn().mockReturnValue(false)
+        };
+        const module = await _testing.Test.createTestingModule({
+            providers: [
+                _emailtemplateservice.EmailTemplateService,
+                {
+                    provide: 'CACHE_INSTANCE',
+                    useValue: {}
+                },
+                {
+                    provide: _modules.UtilsService,
+                    useValue: {}
+                },
+                {
+                    provide: _emailconfigservice.EmailConfigService,
+                    useValue: mockEmailConfig
+                },
+                {
+                    provide: _emaildatasourceprovider.EmailDataSourceProvider,
+                    useValue: mockDataSourceProvider
+                }
+            ]
+        }).compile();
+        service = await module.resolve(_emailtemplateservice.EmailTemplateService);
+        // convertSingleDtoToEntity accesses `this.repository` directly; normally it is
+        // lazily initialized by insert()/update() via ensureDataSourceRepository() first.
+        await service.ensureDataSourceRepository();
+    });
+    describe('resolveEntity', ()=>{
+        it('resolves the plain EmailTemplate entity when the company feature is disabled', ()=>{
+            expect(service.resolveEntity()).toBe(_entities.EmailTemplate);
+        });
+        it('resolves EmailTemplateWithCompany when the company feature is enabled', ()=>{
+            mockEmailConfig.isCompanyFeatureEnabled.mockReturnValue(true);
+            expect(service.resolveEntity()).toBe(_entities.EmailTemplateWithCompany);
+        });
+    });
+    describe('convertSingleDtoToEntity', ()=>{
+        it('creates a new entity (no schema-version bump) for an insert without id', async ()=>{
+            mockRepo.create.mockReturnValue({});
+            const entity = await service.convertSingleDtoToEntity({
+                name: 'Welcome',
+                slug: 'welcome',
+                subject: 'Hi {{name}}',
+                schema: {
+                    fields: []
+                },
+                htmlContent: '<p>Hi {{name}}</p>'
+            }, (0, _loggedusermock.buildMockUser)());
+            expect(entity.schemaVersion).toBeUndefined();
+            expect(mockRepo.findOne).not.toHaveBeenCalled();
+        });
+        it('increments schemaVersion on update when the schema payload changed', async ()=>{
+            // convertSingleDtoToEntity (ApiService base) mutates the fetched row in place via
+            // Object.assign, and incrementSchemaVersionIfChanged re-fetches by id afterwards —
+            // so the mock must return a fresh clone per call, like a real repository would.
+            mockRepo.findOne.mockImplementation(async ()=>buildTemplate({
+                    schema: {
+                        fields: []
+                    },
+                    schemaVersion: 3
+                }));
+            const entity = await service.convertSingleDtoToEntity({
+                id: 'template-uuid-1',
+                schema: {
+                    fields: [
+                        {
+                            name: 'x'
+                        }
+                    ]
+                }
+            }, (0, _loggedusermock.buildMockUser)());
+            expect(entity.schemaVersion).toBe(4);
+        });
+        it('does not increment schemaVersion on update when the schema payload is unchanged', async ()=>{
+            mockRepo.findOne.mockImplementation(async ()=>buildTemplate({
+                    schema: {
+                        fields: []
+                    },
+                    schemaVersion: 3
+                }));
+            const entity = await service.convertSingleDtoToEntity({
+                id: 'template-uuid-1',
+                schema: {
+                    fields: []
+                }
+            }, (0, _loggedusermock.buildMockUser)());
+            expect(entity.schemaVersion).toBe(3);
+        });
+        it('does not touch schemaVersion when the update payload has no schema field', async ()=>{
+            const existing = buildTemplate({
+                schema: {
+                    fields: []
+                },
+                schemaVersion: 3
+            });
+            mockRepo.findOne.mockResolvedValue(existing);
+            const entity = await service.convertSingleDtoToEntity({
+                id: 'template-uuid-1',
+                name: 'Renamed'
+            }, (0, _loggedusermock.buildMockUser)());
+            expect(entity.schemaVersion).toBe(3);
+            // ensureDataSourceRepository/findOne should only be hit once — by the base
+            // convertSingleDtoToEntity — not a second time by incrementSchemaVersionIfChanged.
+            expect(mockRepo.findOne).toHaveBeenCalledTimes(1);
+        });
+        it('attaches the current user companyId when the company feature is enabled', async ()=>{
+            mockEmailConfig.isCompanyFeatureEnabled.mockReturnValue(true);
+            mockRepo.create.mockReturnValue({});
+            const entity = await service.convertSingleDtoToEntity({
+                name: 'Welcome',
+                slug: 'welcome',
+                subject: 'Hi',
+                schema: {},
+                htmlContent: '<p/>'
+            }, (0, _loggedusermock.buildMockUser)({
+                companyId: 'company-uuid-7'
+            }));
+            expect(entity.companyId).toBe('company-uuid-7');
+        });
+    });
+    describe('getSelectQuery', ()=>{
+        it('selects the default whitelisted fields (without companyId) when company feature is disabled', async ()=>{
+            const query = buildQuery();
+            await service.getSelectQuery(query, (0, _loggedusermock.buildMockUser)());
+            const [selected] = query.select.mock.calls[0];
+            expect(selected).toEqual(expect.arrayContaining([
+                'emailTemplate.id',
+                'emailTemplate.name',
+                'emailTemplate.slug',
+                'emailTemplate.subject',
+                'emailTemplate.htmlContent',
+                'emailTemplate.textContent',
+                'emailTemplate.schemaVersion',
+                'emailTemplate.isActive',
+                'emailTemplate.isHtml'
+            ]));
+            expect(selected).not.toContain('emailTemplate.companyId');
+        });
+        it('appends companyId to the default field list when company feature is enabled', async ()=>{
+            mockEmailConfig.isCompanyFeatureEnabled.mockReturnValue(true);
+            const query = buildQuery();
+            await service.getSelectQuery(query, (0, _loggedusermock.buildMockUser)());
+            const [selected] = query.select.mock.calls[0];
+            expect(selected).toContain('emailTemplate.companyId');
+        });
+    });
+    describe('getExtraManipulateQuery', ()=>{
+        it('applies the company filter and orders by createdAt DESC when company feature is enabled', async ()=>{
+            mockEmailConfig.isCompanyFeatureEnabled.mockReturnValue(true);
+            const query = buildQuery();
+            await service.getExtraManipulateQuery(query, {}, (0, _loggedusermock.buildMockUser)({
+                companyId: 'c-1'
+            }));
+            expect(query.andWhere).toHaveBeenCalledWith('emailTemplate.companyId = :companyId', {
+                companyId: 'c-1'
+            });
+            expect(query.orderBy).toHaveBeenCalledWith('emailTemplate.createdAt', 'DESC');
+        });
+    });
+    describe('findByIdDirect', ()=>{
+        it('returns the matching template', async ()=>{
+            const template = buildTemplate();
+            mockRepo.findOne.mockResolvedValue(template);
+            const result = await service.findByIdDirect('template-uuid-1');
+            expect(result).toBe(template);
+            expect(mockRepo.findOne).toHaveBeenCalledWith({
+                where: {
+                    id: 'template-uuid-1'
+                }
+            });
+        });
+    });
+    describe('findBySlug', ()=>{
+        it('finds an active template by slug', async ()=>{
+            const template = buildTemplate();
+            mockRepo.findOne.mockResolvedValue(template);
+            const result = await service.findBySlug('welcome-email', (0, _loggedusermock.buildMockUser)());
+            expect(result).toBe(template);
+            expect(mockRepo.findOne).toHaveBeenCalledWith({
+                where: {
+                    slug: 'welcome-email',
+                    isActive: true
+                }
+            });
+        });
+        it('scopes the slug lookup to the current company when the company feature is enabled', async ()=>{
+            mockEmailConfig.isCompanyFeatureEnabled.mockReturnValue(true);
+            mockRepo.findOne.mockResolvedValue(null);
+            await service.findBySlug('welcome-email', (0, _loggedusermock.buildMockUser)({
+                companyId: 'company-uuid-3'
+            }));
+            expect(mockRepo.findOne).toHaveBeenCalledWith({
+                where: {
+                    slug: 'welcome-email',
+                    isActive: true,
+                    companyId: 'company-uuid-3'
+                }
+            });
+        });
+        it('returns null when no template matches the slug', async ()=>{
+            mockRepo.findOne.mockResolvedValue(null);
+            await expect(service.findBySlug('missing-slug', (0, _loggedusermock.buildMockUser)())).resolves.toBeNull();
+        });
+    });
+});

package/cjs/utils/email-templates.util.spec.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _emailtemplatesutil = require("./email-templates.util");
+describe('email-templates.util', ()=>{
+    describe('getOtpEmailFormat', ()=>{
+        it('renders the OTP inside the generated HTML document', ()=>{
+            const html = (0, _emailtemplatesutil.getOtpEmailFormat)(123456, 'Jane');
+            expect(html).toContain('<!DOCTYPE html>');
+            expect(html).toContain('123456');
+            expect(html).toContain('Hi Jane,');
+            expect(html).toContain('Your OTP Code');
+        });
+        it('falls back to a generic greeting when userName is not provided', ()=>{
+            const html = (0, _emailtemplatesutil.getOtpEmailFormat)(654321);
+            expect(html).toContain('Hi Sir/Madam,');
+        });
+        it('falls back to a generic greeting when userName is null', ()=>{
+            const html = (0, _emailtemplatesutil.getOtpEmailFormat)(111111, null);
+            expect(html).toContain('Hi Sir/Madam,');
+        });
+        it('does not escape HTML special characters in userName (XSS caveat)', ()=>{
+            const html = (0, _emailtemplatesutil.getOtpEmailFormat)(999999, '<script>alert(1)</script>');
+            // Documents CURRENT behavior: userName is interpolated verbatim, unescaped.
+            expect(html).toContain('<script>alert(1)</script>');
+            expect(html).not.toContain('&lt;script&gt;');
+        });
+        it('includes styling for the OTP action box', ()=>{
+            const html = (0, _emailtemplatesutil.getOtpEmailFormat)(1, 'A');
+            expect(html).toContain('letter-spacing: 6px');
+        });
+    });
+    describe('getResetPasswordEmailFormat', ()=>{
+        it('renders the reset link as the href of the action button', ()=>{
+            const html = (0, _emailtemplatesutil.getResetPasswordEmailFormat)('https://app.example.com/reset?token=abc', 'Bob');
+            expect(html).toContain('href="https://app.example.com/reset?token=abc"');
+            expect(html).toContain('Hi Bob,');
+            expect(html).toContain('Reset Your Password');
+        });
+        it('falls back to a generic greeting when userName is omitted', ()=>{
+            const html = (0, _emailtemplatesutil.getResetPasswordEmailFormat)('https://app.example.com/reset?token=abc');
+            expect(html).toContain('Hi Sir/Madam,');
+        });
+        it('does not escape or validate the reset link (XSS/HTML-injection caveat)', ()=>{
+            const maliciousLink = '"><script>alert(1)</script>';
+            const html = (0, _emailtemplatesutil.getResetPasswordEmailFormat)(maliciousLink, 'Bob');
+            // Documents CURRENT behavior: resetLink is interpolated verbatim, unescaped,
+            // allowing HTML attribute breakout if the value is attacker-influenced.
+            expect(html).toContain(`href="${maliciousLink}"`);
+        });
+        it('does not escape HTML special characters in userName', ()=>{
+            const html = (0, _emailtemplatesutil.getResetPasswordEmailFormat)('https://x.test/reset', '<img src=x onerror=alert(1)>');
+            expect(html).toContain('<img src=x onerror=alert(1)>');
+        });
+        it('produces a single-line action-box style for the reset button', ()=>{
+            const html = (0, _emailtemplatesutil.getResetPasswordEmailFormat)('https://x.test/reset', 'A');
+            expect(html).toContain('font-size: 16px');
+        });
+    });
+});

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

@@ -0,0 +1,81 @@
+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.spec.js

@@ -0,0 +1,135 @@
+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.spec.js

@@ -0,0 +1,85 @@
+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);
+        });
+    });
+});

package/fesm/docs/email-swagger.config.spec.js

@@ -0,0 +1,58 @@
+import { emailSwaggerConfig } from './email-swagger.config';
+describe('emailSwaggerConfig', ()=>{
+    it('should default to company feature enabled and single-database mode when no config is given', ()=>{
+        const config = emailSwaggerConfig();
+        expect(config.title).toBe('Email API');
+        expect(config.bearerAuth).toBe(true);
+        expect(config.excludeSchemaProperties).toBeUndefined();
+        expect(config.description).not.toContain('Multi-Tenant Mode');
+    });
+    it('should exclude companyId schema properties when the company feature is disabled', ()=>{
+        const config = emailSwaggerConfig({
+            enableCompanyFeature: false
+        });
+        expect(config.excludeSchemaProperties).toEqual([
+            {
+                schemaName: 'EmailConfigResponseDto',
+                properties: [
+                    'companyId'
+                ]
+            },
+            {
+                schemaName: 'EmailTemplateResponseDto',
+                properties: [
+                    'companyId'
+                ]
+            }
+        ]);
+    });
+    it('should not exclude any schema properties when the company feature is enabled', ()=>{
+        const config = emailSwaggerConfig({
+            enableCompanyFeature: true
+        });
+        expect(config.excludeSchemaProperties).toBeUndefined();
+    });
+    it('should describe company isolation and multi-tenant support only when the company feature is enabled', ()=>{
+        const withCompany = emailSwaggerConfig({
+            enableCompanyFeature: true
+        });
+        const withoutCompany = emailSwaggerConfig({
+            enableCompanyFeature: false
+        });
+        expect(withCompany.description).toContain('Company isolation');
+        expect(withCompany.description).toContain('## Multi-Tenant Support');
+        expect(withCompany.description).toContain('with multi-tenant and company support');
+        expect(withoutCompany.description).not.toContain('Company isolation');
+        expect(withoutCompany.description).not.toContain('## Multi-Tenant Support');
+    });
+    it('should mention multi-tenant mode in the description only for multi-tenant database mode', ()=>{
+        const multiTenant = emailSwaggerConfig({
+            databaseMode: 'multi-tenant'
+        });
+        const single = emailSwaggerConfig({
+            databaseMode: 'single'
+        });
+        expect(multiTenant.description).toContain('Multi-Tenant Mode');
+        expect(single.description).not.toContain('Multi-Tenant Mode');
+    });
+});