@flusys/nestjs-auth 6.0.2 → 6.1.1

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

@@ -0,0 +1,404 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _common = require("@nestjs/common");
+const _bcrypt = /*#__PURE__*/ _interop_require_wildcard(require("bcrypt"));
+const _repositorymock = require("@test-utils/mocks/repository.mock");
+const _authemailservice = require("./auth-email.service");
+const _appuserentity = require("../entities/app-user.entity");
+const _pendingregistrationentity = require("../entities/pending-registration.entity");
+const _usertokenentity = require("../entities/user-token.entity");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+jest.mock('bcrypt', ()=>({
+        hash: jest.fn().mockResolvedValue('hashed-password')
+    }));
+function buildUser(overrides = {}) {
+    return {
+        id: 'user-1',
+        email: 'user@example.com',
+        isActive: true,
+        emailVerified: false,
+        password: 'hashed',
+        ...overrides
+    };
+}
+function buildUserToken(overrides = {}) {
+    return {
+        id: 'token-1',
+        userId: 'user-1',
+        type: _usertokenentity.TokenType.PASSWORD_RESET,
+        token: 'hashed-token',
+        expiresAt: new Date(Date.now() + 60_000),
+        usedAt: null,
+        createdAt: new Date(),
+        ...overrides
+    };
+}
+describe('AuthEmailService', ()=>{
+    let service;
+    let userRepo;
+    let pendingRepo;
+    let tokenRepo;
+    let mockEmailProvider;
+    beforeEach(()=>{
+        userRepo = (0, _repositorymock.createMockRepository)();
+        pendingRepo = (0, _repositorymock.createMockRepository)();
+        tokenRepo = (0, _repositorymock.createMockRepository)();
+        const dataSourceProvider = {
+            getRepository: jest.fn().mockImplementation(async (entity)=>{
+                if (entity === _appuserentity.AppUser) return userRepo;
+                if (entity === _pendingregistrationentity.PendingRegistration) return pendingRepo;
+                if (entity === _usertokenentity.UserToken) return tokenRepo;
+                throw new Error(`Unexpected entity requested: ${String(entity)}`);
+            }),
+            getDataSource: jest.fn()
+        };
+        mockEmailProvider = {
+            sendPasswordResetEmail: jest.fn().mockResolvedValue(undefined),
+            sendVerificationEmail: jest.fn().mockResolvedValue(undefined)
+        };
+        service = new _authemailservice.AuthEmailService(dataSourceProvider, mockEmailProvider);
+    });
+    afterEach(()=>jest.clearAllMocks());
+    describe('isEmailEnabled', ()=>{
+        it('returns true when an email provider is configured', ()=>{
+            expect(service.isEmailEnabled()).toBe(true);
+        });
+        it('returns false when no email provider is configured', ()=>{
+            const noEmailService = new _authemailservice.AuthEmailService((0, _repositorymock.createMockDataSourceProvider)(userRepo), undefined);
+            expect(noEmailService.isEmailEnabled()).toBe(false);
+        });
+    });
+    describe('hasPendingRegistration', ()=>{
+        it('returns false when email is disabled without querying', async ()=>{
+            const noEmailService = new _authemailservice.AuthEmailService((0, _repositorymock.createMockDataSourceProvider)(pendingRepo), undefined);
+            const result = await noEmailService.hasPendingRegistration('user@example.com');
+            expect(result).toBe(false);
+        });
+        it('returns true when a non-expired pending registration exists', async ()=>{
+            pendingRepo.findOne.mockResolvedValue({
+                expiresAt: new Date(Date.now() + 60_000)
+            });
+            const result = await service.hasPendingRegistration('user@example.com');
+            expect(result).toBe(true);
+        });
+        it('returns false when the pending registration has expired', async ()=>{
+            pendingRepo.findOne.mockResolvedValue({
+                expiresAt: new Date(Date.now() - 60_000)
+            });
+            const result = await service.hasPendingRegistration('user@example.com');
+            expect(result).toBe(false);
+        });
+        it('returns false when no pending registration exists', async ()=>{
+            pendingRepo.findOne.mockResolvedValue(null);
+            const result = await service.hasPendingRegistration('user@example.com');
+            expect(result).toBe(false);
+        });
+    });
+    describe('createPendingRegistration', ()=>{
+        it('throws BadRequestException when email service is not configured', async ()=>{
+            const noEmailService = new _authemailservice.AuthEmailService((0, _repositorymock.createMockDataSourceProvider)(userRepo), undefined);
+            await expect(noEmailService.createPendingRegistration({
+                email: 'new@example.com',
+                password: 'Password1!',
+                verifyUrlBase: 'https://app.test/verify'
+            })).rejects.toThrow(_common.BadRequestException);
+        });
+        it('throws BadRequestException when the user already exists', async ()=>{
+            userRepo.findOne.mockResolvedValue(buildUser());
+            await expect(service.createPendingRegistration({
+                email: 'user@example.com',
+                password: 'Password1!',
+                verifyUrlBase: 'https://app.test/verify'
+            })).rejects.toThrow(_common.BadRequestException);
+        });
+        it('creates a pending registration, hashes the password, and sends verification email', async ()=>{
+            userRepo.findOne.mockResolvedValue(null);
+            pendingRepo.create.mockImplementation((data)=>data);
+            pendingRepo.save.mockResolvedValue({});
+            const result = await service.createPendingRegistration({
+                email: 'new@example.com',
+                name: 'New User',
+                password: 'Password1!',
+                verifyUrlBase: 'https://app.test/verify'
+            });
+            expect(pendingRepo.delete).toHaveBeenCalledWith({
+                email: 'new@example.com'
+            });
+            expect(_bcrypt.hash).toHaveBeenCalledWith('Password1!', 12);
+            expect(pendingRepo.save).toHaveBeenCalled();
+            expect(mockEmailProvider.sendVerificationEmail).toHaveBeenCalledWith('new@example.com', expect.any(String), expect.stringContaining('https://app.test/verify?token='));
+            expect(result.success).toBe(true);
+        });
+        it('wraps a failed verification email send in BadRequestException', async ()=>{
+            userRepo.findOne.mockResolvedValue(null);
+            pendingRepo.create.mockImplementation((data)=>data);
+            pendingRepo.save.mockResolvedValue({});
+            mockEmailProvider.sendVerificationEmail.mockRejectedValue(new Error('smtp down'));
+            await expect(service.createPendingRegistration({
+                email: 'new@example.com',
+                password: 'Password1!',
+                verifyUrlBase: 'https://app.test/verify'
+            })).rejects.toThrow(_common.BadRequestException);
+        });
+    });
+    describe('forgotPassword', ()=>{
+        it('returns a generic success message when the user does not exist (prevents enumeration)', async ()=>{
+            userRepo.findOne.mockResolvedValue(null);
+            const result = await service.forgotPassword('missing@example.com', 'https://app.test/reset');
+            expect(result.success).toBe(true);
+            expect(tokenRepo.save).not.toHaveBeenCalled();
+        });
+        it('returns a generic success message when the user is inactive (prevents enumeration)', async ()=>{
+            userRepo.findOne.mockResolvedValue(buildUser({
+                isActive: false
+            }));
+            const result = await service.forgotPassword('user@example.com', 'https://app.test/reset');
+            expect(result.success).toBe(true);
+            expect(tokenRepo.save).not.toHaveBeenCalled();
+        });
+        it('invalidates existing tokens and creates a new hashed reset token for an active user', async ()=>{
+            userRepo.findOne.mockResolvedValue(buildUser());
+            tokenRepo.create.mockImplementation((data)=>data);
+            tokenRepo.save.mockResolvedValue({});
+            const result = await service.forgotPassword('user@example.com', 'https://app.test/reset');
+            expect(tokenRepo.delete).toHaveBeenCalledWith({
+                userId: 'user-1',
+                type: _usertokenentity.TokenType.PASSWORD_RESET
+            });
+            expect(tokenRepo.save).toHaveBeenCalled();
+            expect(mockEmailProvider.sendPasswordResetEmail).toHaveBeenCalledWith('user@example.com', expect.any(String), expect.stringContaining('https://app.test/reset?token='));
+            expect(result.success).toBe(true);
+        });
+        it('wraps a failed password-reset email send in BadRequestException', async ()=>{
+            userRepo.findOne.mockResolvedValue(buildUser());
+            tokenRepo.create.mockImplementation((data)=>data);
+            tokenRepo.save.mockResolvedValue({});
+            mockEmailProvider.sendPasswordResetEmail.mockRejectedValue(new Error('smtp down'));
+            await expect(service.forgotPassword('user@example.com', 'https://app.test/reset')).rejects.toThrow(_common.BadRequestException);
+        });
+    });
+    describe('resetPassword', ()=>{
+        it('throws BadRequestException when the token is not found', async ()=>{
+            tokenRepo.findOne.mockResolvedValue(null);
+            await expect(service.resetPassword('bad-token', 'NewPassword1!')).rejects.toThrow(_common.BadRequestException);
+        });
+        it('throws BadRequestException when the token has expired', async ()=>{
+            tokenRepo.findOne.mockResolvedValue(buildUserToken({
+                expiresAt: new Date(Date.now() - 60_000)
+            }));
+            await expect(service.resetPassword('token', 'NewPassword1!')).rejects.toThrow(_common.BadRequestException);
+        });
+        it('throws BadRequestException when the token has already been used', async ()=>{
+            tokenRepo.findOne.mockResolvedValue(buildUserToken({
+                usedAt: new Date()
+            }));
+            await expect(service.resetPassword('token', 'NewPassword1!')).rejects.toThrow(_common.BadRequestException);
+        });
+        it('throws BadRequestException when the associated user no longer exists', async ()=>{
+            tokenRepo.findOne.mockResolvedValue(buildUserToken());
+            userRepo.findOne.mockResolvedValue(null);
+            await expect(service.resetPassword('token', 'NewPassword1!')).rejects.toThrow(_common.BadRequestException);
+        });
+        it('hashes the new password, saves the user, and marks the token as used', async ()=>{
+            const token = buildUserToken();
+            tokenRepo.findOne.mockResolvedValue(token);
+            userRepo.findOne.mockResolvedValue(buildUser());
+            userRepo.save.mockResolvedValue(buildUser());
+            tokenRepo.save.mockResolvedValue(token);
+            const result = await service.resetPassword('raw-token', 'NewPassword1!');
+            expect(_bcrypt.hash).toHaveBeenCalledWith('NewPassword1!', 12);
+            expect(userRepo.save).toHaveBeenCalled();
+            expect(tokenRepo.save).toHaveBeenCalledWith(expect.objectContaining({
+                usedAt: expect.any(Date)
+            }));
+            expect(result.success).toBe(true);
+        });
+    });
+    describe('verifyEmail', ()=>{
+        it('resolves a pending registration and deletes it', async ()=>{
+            const pending = {
+                id: 'pending-1',
+                email: 'new@example.com',
+                expiresAt: new Date(Date.now() + 60_000)
+            };
+            pendingRepo.findOne.mockResolvedValue(pending);
+            const result = await service.verifyEmail('raw-token');
+            expect(result).toEqual({
+                type: 'pending',
+                pending
+            });
+            expect(pendingRepo.delete).toHaveBeenCalledWith({
+                id: 'pending-1'
+            });
+        });
+        it('deletes and throws when the pending registration has expired', async ()=>{
+            const pending = {
+                id: 'pending-1',
+                expiresAt: new Date(Date.now() - 60_000)
+            };
+            pendingRepo.findOne.mockResolvedValue(pending);
+            await expect(service.verifyEmail('raw-token')).rejects.toThrow(_common.BadRequestException);
+            expect(pendingRepo.delete).toHaveBeenCalledWith({
+                id: 'pending-1'
+            });
+        });
+        it('throws BadRequestException when no pending registration or user token is found', async ()=>{
+            pendingRepo.findOne.mockResolvedValue(null);
+            tokenRepo.findOne.mockResolvedValue(null);
+            await expect(service.verifyEmail('raw-token')).rejects.toThrow(_common.BadRequestException);
+        });
+        it('deletes and throws when the user token has expired', async ()=>{
+            pendingRepo.findOne.mockResolvedValue(null);
+            tokenRepo.findOne.mockResolvedValue(buildUserToken({
+                type: _usertokenentity.TokenType.EMAIL_VERIFICATION,
+                expiresAt: new Date(Date.now() - 60_000)
+            }));
+            await expect(service.verifyEmail('raw-token')).rejects.toThrow(_common.BadRequestException);
+            expect(tokenRepo.delete).toHaveBeenCalled();
+        });
+        it('returns already-verified message when the token has already been used', async ()=>{
+            pendingRepo.findOne.mockResolvedValue(null);
+            tokenRepo.findOne.mockResolvedValue(buildUserToken({
+                type: _usertokenentity.TokenType.EMAIL_VERIFICATION,
+                usedAt: new Date()
+            }));
+            const result = await service.verifyEmail('raw-token');
+            expect(result).toEqual(expect.objectContaining({
+                type: 'verified',
+                message: 'Email has already been verified.'
+            }));
+        });
+        it('throws BadRequestException when the user for the token no longer exists', async ()=>{
+            pendingRepo.findOne.mockResolvedValue(null);
+            tokenRepo.findOne.mockResolvedValue(buildUserToken({
+                type: _usertokenentity.TokenType.EMAIL_VERIFICATION
+            }));
+            userRepo.findOne.mockResolvedValue(null);
+            await expect(service.verifyEmail('raw-token')).rejects.toThrow(_common.BadRequestException);
+        });
+        it('marks the user email verified and the token used on success', async ()=>{
+            const token = buildUserToken({
+                type: _usertokenentity.TokenType.EMAIL_VERIFICATION
+            });
+            pendingRepo.findOne.mockResolvedValue(null);
+            tokenRepo.findOne.mockResolvedValue(token);
+            userRepo.findOne.mockResolvedValue(buildUser({
+                emailVerified: false
+            }));
+            userRepo.save.mockResolvedValue({});
+            tokenRepo.save.mockResolvedValue({});
+            const result = await service.verifyEmail('raw-token');
+            expect(userRepo.save).toHaveBeenCalledWith(expect.objectContaining({
+                emailVerified: true
+            }));
+            expect(tokenRepo.save).toHaveBeenCalledWith(expect.objectContaining({
+                usedAt: expect.any(Date)
+            }));
+            expect(result).toEqual(expect.objectContaining({
+                type: 'verified'
+            }));
+        });
+    });
+    describe('resendVerificationEmail', ()=>{
+        it('throws BadRequestException when email service is not configured', async ()=>{
+            const noEmailService = new _authemailservice.AuthEmailService((0, _repositorymock.createMockDataSourceProvider)(pendingRepo), undefined);
+            await expect(noEmailService.resendVerificationEmail('user@example.com', 'https://app.test/verify')).rejects.toThrow(_common.BadRequestException);
+        });
+        it('resends verification for a pending registration', async ()=>{
+            const pending = {
+                email: 'new@example.com',
+                token: 'old-hash',
+                expiresAt: new Date()
+            };
+            pendingRepo.findOne.mockResolvedValue(pending);
+            pendingRepo.save.mockResolvedValue(pending);
+            const result = await service.resendVerificationEmail('new@example.com', 'https://app.test/verify');
+            expect(pendingRepo.save).toHaveBeenCalled();
+            expect(mockEmailProvider.sendVerificationEmail).toHaveBeenCalled();
+            expect(result.success).toBe(true);
+        });
+        it('returns generic success without sending when the user does not exist (prevents enumeration)', async ()=>{
+            pendingRepo.findOne.mockResolvedValue(null);
+            userRepo.findOne.mockResolvedValue(null);
+            const result = await service.resendVerificationEmail('missing@example.com', 'https://app.test/verify');
+            expect(result.success).toBe(true);
+            expect(mockEmailProvider.sendVerificationEmail).not.toHaveBeenCalled();
+        });
+        it('returns generic success without sending when the user is already verified', async ()=>{
+            pendingRepo.findOne.mockResolvedValue(null);
+            userRepo.findOne.mockResolvedValue(buildUser({
+                emailVerified: true
+            }));
+            const result = await service.resendVerificationEmail('user@example.com', 'https://app.test/verify');
+            expect(result.success).toBe(true);
+            expect(mockEmailProvider.sendVerificationEmail).not.toHaveBeenCalled();
+        });
+        it('invalidates old tokens and sends a new verification token for an unverified user', async ()=>{
+            pendingRepo.findOne.mockResolvedValue(null);
+            userRepo.findOne.mockResolvedValue(buildUser({
+                emailVerified: false
+            }));
+            tokenRepo.create.mockImplementation((data)=>data);
+            tokenRepo.save.mockResolvedValue({});
+            const result = await service.resendVerificationEmail('user@example.com', 'https://app.test/verify');
+            expect(tokenRepo.delete).toHaveBeenCalledWith({
+                userId: 'user-1',
+                type: _usertokenentity.TokenType.EMAIL_VERIFICATION
+            });
+            expect(mockEmailProvider.sendVerificationEmail).toHaveBeenCalled();
+            expect(result.success).toBe(true);
+        });
+    });
+    describe('getRepository failure path', ()=>{
+        it('throws InternalServerErrorException when the data source provider is unavailable', async ()=>{
+            const noDataSourceService = new _authemailservice.AuthEmailService(undefined, mockEmailProvider);
+            await expect(noDataSourceService.createPendingRegistration({
+                email: 'new@example.com',
+                password: 'Password1!',
+                verifyUrlBase: 'https://app.test/verify'
+            })).rejects.toThrow(_common.InternalServerErrorException);
+        });
+    });
+});