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

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

@@ -1,456 +0,0 @@
-"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 _classes = require("@flusys/nestjs-shared/classes");
-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);
-        });
-    });
-    describe('domain events', ()=>{
-        let publish;
-        beforeEach(()=>{
-            publish = jest.fn().mockResolvedValue(undefined);
-            _classes.EventBusRegistry.reset();
-            _classes.EventBusRegistry.setBus({
-                publish,
-                subscribe: jest.fn(),
-                close: jest.fn()
-            });
-            _classes.EventBusRegistry.configureModule('auth', {
-                enabled: true
-            });
-        });
-        afterEach(()=>{
-            _classes.EventBusRegistry.reset();
-        });
-        it('publishes auth.appuser.password-reset-requested once the reset email is sent', async ()=>{
-            userRepo.findOne.mockResolvedValue(buildUser());
-            tokenRepo.save.mockResolvedValue(buildUserToken());
-            await service.forgotPassword('user@example.com', 'https://app.test/reset');
-            expect(publish).toHaveBeenCalledWith(expect.objectContaining({
-                name: 'auth.appuser.password-reset-requested'
-            }));
-        });
-        it('publishes nothing for an unknown email so enumeration stays impossible', async ()=>{
-            userRepo.findOne.mockResolvedValue(null);
-            await service.forgotPassword('missing@example.com', 'https://app.test/reset');
-            expect(publish).not.toHaveBeenCalled();
-        });
-        it('publishes auth.appuser.password-reset when the token is consumed', async ()=>{
-            const token = buildUserToken();
-            tokenRepo.findOne.mockResolvedValue(token);
-            userRepo.findOne.mockResolvedValue(buildUser());
-            userRepo.save.mockResolvedValue(buildUser());
-            tokenRepo.save.mockResolvedValue(token);
-            await service.resetPassword('raw-token', 'NewPassword1!');
-            expect(publish).toHaveBeenCalledWith(expect.objectContaining({
-                name: 'auth.appuser.password-reset'
-            }));
-        });
-        it('does not publish when the auth module has events disabled', async ()=>{
-            _classes.EventBusRegistry.configureModule('auth', {
-                enabled: false
-            });
-            userRepo.findOne.mockResolvedValue(buildUser());
-            tokenRepo.save.mockResolvedValue(buildUserToken());
-            await service.forgotPassword('user@example.com', 'https://app.test/reset');
-            expect(publish).not.toHaveBeenCalled();
-        });
-    });
-});