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

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

@@ -1,539 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "AuthEmailService", {
-    enumerable: true,
-    get: function() {
-        return AuthEmailService;
-    }
-});
-const _nestjsshared = require("@flusys/nestjs-shared");
-const _classes = require("@flusys/nestjs-shared/classes");
-const _constants = require("@flusys/nestjs-shared/constants");
-const _common = require("@nestjs/common");
-const _bcrypt = /*#__PURE__*/ _interop_require_wildcard(require("bcrypt"));
-const _crypto = /*#__PURE__*/ _interop_require_wildcard(require("crypto"));
-const _config = require("../config");
-const _appuserentity = require("../entities/app-user.entity");
-const _pendingregistrationentity = require("../entities/pending-registration.entity");
-const _usertokenentity = require("../entities/user-token.entity");
-const _interfaces = require("../interfaces");
-const _authdatasourceprovider = require("./auth-datasource.provider");
-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 _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;
-}
-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);
-    };
-}
-let AuthEmailService = class AuthEmailService {
-    isEmailEnabled() {
-        return !!this.emailProvider;
-    }
-    async getRepository(entity) {
-        if (!this.dataSourceProvider) {
-            throw new _common.InternalServerErrorException({
-                message: `${String(entity)} repository not available`,
-                messageKey: _constants.SYSTEM_MESSAGES.REPOSITORY_NOT_AVAILABLE,
-                messageVariables: {
-                    entity: String(entity)
-                }
-            });
-        }
-        return this.dataSourceProvider.getRepository(entity);
-    }
-    generateToken() {
-        return _crypto.randomBytes(32).toString('hex');
-    }
-    hashToken(token) {
-        return _crypto.createHash('sha256').update(token).digest('hex');
-    }
-    assertEmailEnabled() {
-        if (!this.emailProvider) {
-            throw new _common.BadRequestException({
-                message: 'Email service is not configured',
-                messageKey: _config.AUTH_MESSAGES.EMAIL_NOT_CONFIGURED
-            });
-        }
-    }
-    async sendVerificationEmailSafe(email, token, verifyUrl) {
-        try {
-            await this.emailProvider.sendVerificationEmail(email, token, verifyUrl);
-        } catch  {
-            throw new _common.BadRequestException({
-                message: 'Failed to send verification email. Please try again.',
-                messageKey: _config.AUTH_MESSAGES.EMAIL_SEND_FAILED
-            });
-        }
-    }
-    validateTokenNotExpiredOrUsed(token, expiredMessage, expiredMessageKey, usedMessage, usedMessageKey) {
-        if (token.expiresAt < new Date()) {
-            throw new _common.BadRequestException({
-                message: expiredMessage,
-                messageKey: expiredMessageKey
-            });
-        }
-        if (usedMessage && usedMessageKey && token.usedAt) {
-            throw new _common.BadRequestException({
-                message: usedMessage,
-                messageKey: usedMessageKey
-            });
-        }
-    }
-    async hasPendingRegistration(email) {
-        if (!this.isEmailEnabled()) return false;
-        const pendingRepository = await this.getRepository(_pendingregistrationentity.PendingRegistration);
-        const pending = await pendingRepository.findOne({
-            where: {
-                email
-            }
-        });
-        return !!pending && pending.expiresAt > new Date();
-    }
-    async createPendingRegistration(data) {
-        this.assertEmailEnabled();
-        const userRepository = await this.getRepository(_appuserentity.AppUser);
-        const pendingRepository = await this.getRepository(_pendingregistrationentity.PendingRegistration);
-        // Check if user already exists
-        const existingUser = await userRepository.findOne({
-            where: {
-                email: data.email
-            }
-        });
-        if (existingUser) {
-            throw new _common.BadRequestException({
-                message: 'Registration failed. Please try again or contact support.',
-                messageKey: _config.AUTH_MESSAGES.REGISTER_FAILED
-            });
-        }
-        // Delete any existing pending registration for this email
-        await pendingRepository.delete({
-            email: data.email
-        });
-        // Create pending registration with hashed token for secure storage
-        const token = this.generateToken();
-        const tokenHash = this.hashToken(token);
-        const passwordHash = await _bcrypt.hash(data.password, _config.BCRYPT_SALT_ROUNDS);
-        const expiresAt = new Date(Date.now() + this.EMAIL_VERIFICATION_EXPIRY);
-        const pending = pendingRepository.create({
-            email: data.email,
-            name: data.name ?? null,
-            phone: data.phone ?? null,
-            passwordHash,
-            token: tokenHash,
-            expiresAt,
-            companyData: data.companyData ?? null,
-            additionalFields: data.additionalFields ?? null
-        });
-        await pendingRepository.save(pending);
-        // Send verification email with raw token (user receives this)
-        const verifyUrl = `${data.verifyUrlBase}?token=${token}`;
-        await this.sendVerificationEmailSafe(data.email, token, verifyUrl);
-        return {
-            success: true,
-            message: 'Please check your email to verify your registration.',
-            messageKey: _config.EMAIL_VERIFICATION_MESSAGES.VERIFICATION_SENT
-        };
-    }
-    async forgotPassword(email, resetUrlBase) {
-        this.assertEmailEnabled();
-        const userRepository = await this.getRepository(_appuserentity.AppUser);
-        const tokenRepository = await this.getRepository(_usertokenentity.UserToken);
-        const user = await userRepository.findOne({
-            where: {
-                email
-            }
-        });
-        // Always return success to prevent email enumeration
-        if (!user || !user.isActive) {
-            return {
-                success: true,
-                message: 'If the email exists, a password reset link has been sent.',
-                messageKey: _config.AUTH_MESSAGES.PASSWORD_RESET_EMAIL_SENT
-            };
-        }
-        // Invalidate existing password reset tokens for this user
-        await tokenRepository.delete({
-            userId: user.id,
-            type: _usertokenentity.TokenType.PASSWORD_RESET
-        });
-        // Create new token with hashed storage
-        const token = this.generateToken();
-        const tokenHash = this.hashToken(token);
-        const userToken = tokenRepository.create({
-            userId: user.id,
-            type: _usertokenentity.TokenType.PASSWORD_RESET,
-            token: tokenHash,
-            expiresAt: new Date(Date.now() + this.PASSWORD_RESET_EXPIRY)
-        });
-        await tokenRepository.save(userToken);
-        // Send email with raw token
-        const resetUrl = `${resetUrlBase}?token=${token}`;
-        try {
-            await this.emailProvider.sendPasswordResetEmail(email, token, resetUrl);
-        } catch  {
-            throw new _common.BadRequestException({
-                message: 'Failed to process request. Please try again later.',
-                messageKey: _constants.SYSTEM_MESSAGES.INTERNAL_ERROR,
-                messageVariables: {
-                    provider: 'EmailProvider',
-                    error: 'Send email failed'
-                }
-            });
-        }
-        await this.publishUserEvent(_config.AUTH_EVENT_ACTIONS.PASSWORD_RESET_REQUESTED, user.id, {
-            email: user.email
-        });
-        return {
-            success: true,
-            message: 'If the email exists, a password reset link has been sent.',
-            messageKey: _config.AUTH_MESSAGES.PASSWORD_RESET_EMAIL_SENT
-        };
-    }
-    async resetPassword(token, newPassword) {
-        const userRepository = await this.getRepository(_appuserentity.AppUser);
-        const tokenRepository = await this.getRepository(_usertokenentity.UserToken);
-        // Hash the incoming token to compare with stored hash
-        const tokenHash = this.hashToken(token);
-        const userToken = await tokenRepository.findOne({
-            where: {
-                token: tokenHash,
-                type: _usertokenentity.TokenType.PASSWORD_RESET
-            }
-        });
-        if (!userToken) {
-            throw new _common.BadRequestException({
-                message: 'Invalid or expired reset token',
-                messageKey: _config.EMAIL_VERIFICATION_MESSAGES.VERIFICATION_TOKEN_INVALID
-            });
-        }
-        this.validateTokenNotExpiredOrUsed(userToken, 'Reset token has expired. Please request a new one.', _config.AUTH_MESSAGES.PASSWORD_RESET_TOKEN_EXPIRED, 'This reset token has already been used.', _config.AUTH_MESSAGES.PASSWORD_RESET_TOKEN_USED);
-        const user = await userRepository.findOne({
-            where: {
-                id: userToken.userId
-            }
-        });
-        if (!user) {
-            throw new _common.BadRequestException({
-                message: 'User not found',
-                messageKey: _config.USER_MESSAGES.NOT_FOUND
-            });
-        }
-        // Update password
-        user.password = await _bcrypt.hash(newPassword, _config.BCRYPT_SALT_ROUNDS);
-        await userRepository.save(user);
-        // Mark token as used
-        userToken.usedAt = new Date();
-        await tokenRepository.save(userToken);
-        await this.publishUserEvent(_config.AUTH_EVENT_ACTIONS.PASSWORD_RESET, user.id, {
-            email: user.email
-        });
-        return {
-            success: true,
-            message: 'Password has been reset successfully.',
-            messageKey: _config.AUTH_MESSAGES.PASSWORD_RESET_SUCCESS
-        };
-    }
-    async verifyEmail(token) {
-        const pendingRepository = await this.getRepository(_pendingregistrationentity.PendingRegistration);
-        const userRepository = await this.getRepository(_appuserentity.AppUser);
-        const tokenRepository = await this.getRepository(_usertokenentity.UserToken);
-        // Hash the incoming token to compare with stored hash
-        const tokenHash = this.hashToken(token);
-        // Check for pending registration first
-        const pending = await pendingRepository.findOne({
-            where: {
-                token: tokenHash
-            }
-        });
-        if (pending) {
-            if (pending.expiresAt < new Date()) {
-                await pendingRepository.delete({
-                    id: pending.id
-                });
-                throw new _common.BadRequestException({
-                    message: 'Verification token has expired. Please register again.',
-                    messageKey: _config.EMAIL_VERIFICATION_MESSAGES.VERIFICATION_TOKEN_EXPIRED
-                });
-            }
-            // Delete pending registration (will be consumed by caller to create user)
-            await pendingRepository.delete({
-                id: pending.id
-            });
-            return {
-                type: 'pending',
-                pending
-            };
-        }
-        // Check for existing user email verification token
-        const userToken = await tokenRepository.findOne({
-            where: {
-                token: tokenHash,
-                type: _usertokenentity.TokenType.EMAIL_VERIFICATION
-            }
-        });
-        if (!userToken) {
-            throw new _common.BadRequestException({
-                message: 'Invalid or expired verification token',
-                messageKey: _config.EMAIL_VERIFICATION_MESSAGES.VERIFICATION_TOKEN_INVALID
-            });
-        }
-        if (userToken.expiresAt < new Date()) {
-            await tokenRepository.delete({
-                id: userToken.id
-            });
-            throw new _common.BadRequestException({
-                message: 'Verification token has expired. Please request a new one.',
-                messageKey: _config.EMAIL_VERIFICATION_MESSAGES.VERIFICATION_TOKEN_EXPIRED
-            });
-        }
-        if (userToken.usedAt) {
-            return {
-                type: 'verified',
-                message: 'Email has already been verified.',
-                messageKey: _config.EMAIL_VERIFICATION_MESSAGES.VERIFICATION_SUCCESS
-            };
-        }
-        const user = await userRepository.findOne({
-            where: {
-                id: userToken.userId
-            }
-        });
-        if (!user) {
-            throw new _common.BadRequestException({
-                message: 'User not found',
-                messageKey: _config.USER_MESSAGES.NOT_FOUND
-            });
-        }
-        // Mark email as verified
-        user.emailVerified = true;
-        await userRepository.save(user);
-        // Mark token as used
-        userToken.usedAt = new Date();
-        await tokenRepository.save(userToken);
-        await this.publishUserEvent(_config.AUTH_EVENT_ACTIONS.EMAIL_VERIFIED, user.id, {
-            email: user.email
-        });
-        return {
-            type: 'verified',
-            message: 'Email has been verified successfully.',
-            messageKey: _config.EMAIL_VERIFICATION_MESSAGES.VERIFICATION_SUCCESS
-        };
-    }
-    async publishUserEvent(action, userId, metadata) {
-        await (0, _classes.publishDomainEvent)({
-            module: _config.AUTH_EVENT_MODULE,
-            entity: _config.AUTH_EVENT_ENTITIES.USER,
-            action,
-            ids: [
-                userId
-            ],
-            metadata
-        });
-    }
-    async resendVerificationEmail(email, verifyUrlBase) {
-        this.assertEmailEnabled();
-        const pendingRepository = await this.getRepository(_pendingregistrationentity.PendingRegistration);
-        const userRepository = await this.getRepository(_appuserentity.AppUser);
-        const tokenRepository = await this.getRepository(_usertokenentity.UserToken);
-        // Check pending registration first
-        const pending = await pendingRepository.findOne({
-            where: {
-                email
-            }
-        });
-        if (pending) {
-            const token = this.generateToken();
-            pending.token = this.hashToken(token);
-            pending.expiresAt = new Date(Date.now() + this.EMAIL_VERIFICATION_EXPIRY);
-            await pendingRepository.save(pending);
-            const verifyUrl = `${verifyUrlBase}?token=${token}`;
-            await this.sendVerificationEmailSafe(email, token, verifyUrl);
-            return {
-                success: true,
-                message: 'If the email requires verification, a link has been sent.',
-                messageKey: _config.EMAIL_VERIFICATION_MESSAGES.RESEND_SUCCESS
-            };
-        }
-        // Check existing user
-        const user = await userRepository.findOne({
-            where: {
-                email
-            }
-        });
-        if (!user || user.emailVerified) {
-            return {
-                success: true,
-                message: 'If the email requires verification, a link has been sent.',
-                messageKey: _config.EMAIL_VERIFICATION_MESSAGES.RESEND_SUCCESS
-            };
-        }
-        // Invalidate existing tokens and create new one
-        await tokenRepository.delete({
-            userId: user.id,
-            type: _usertokenentity.TokenType.EMAIL_VERIFICATION
-        });
-        const token = this.generateToken();
-        const userToken = tokenRepository.create({
-            userId: user.id,
-            type: _usertokenentity.TokenType.EMAIL_VERIFICATION,
-            token: this.hashToken(token),
-            expiresAt: new Date(Date.now() + this.EMAIL_VERIFICATION_EXPIRY)
-        });
-        await tokenRepository.save(userToken);
-        const verifyUrl = `${verifyUrlBase}?token=${token}`;
-        await this.sendVerificationEmailSafe(user.email, token, verifyUrl);
-        return {
-            success: true,
-            message: 'If the email requires verification, a link has been sent.',
-            messageKey: _config.EMAIL_VERIFICATION_MESSAGES.RESEND_SUCCESS
-        };
-    }
-    constructor(dataSourceProvider, emailProvider){
-        _define_property(this, "dataSourceProvider", void 0);
-        _define_property(this, "emailProvider", void 0);
-        _define_property(this, "PASSWORD_RESET_EXPIRY", void 0); // 1 hour
-        _define_property(this, "EMAIL_VERIFICATION_EXPIRY", void 0); // 24 hours
-        this.dataSourceProvider = dataSourceProvider;
-        this.emailProvider = emailProvider;
-        this.PASSWORD_RESET_EXPIRY = 60 * 60 * 1000;
-        this.EMAIL_VERIFICATION_EXPIRY = 24 * 60 * 60 * 1000;
-    }
-};
-_ts_decorate([
-    (0, _nestjsshared.LogAction)({
-        action: 'auth.createPendingRegistration',
-        module: 'auth',
-        includeParams: false
-    }),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        Object
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], AuthEmailService.prototype, "createPendingRegistration", null);
-_ts_decorate([
-    (0, _nestjsshared.LogAction)({
-        action: 'auth.forgotPassword',
-        module: 'auth',
-        includeParams: false
-    }),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        String,
-        String
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], AuthEmailService.prototype, "forgotPassword", null);
-_ts_decorate([
-    (0, _nestjsshared.LogAction)({
-        action: 'auth.resetPassword',
-        module: 'auth',
-        includeParams: false
-    }),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        String,
-        String
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], AuthEmailService.prototype, "resetPassword", null);
-_ts_decorate([
-    (0, _nestjsshared.LogAction)({
-        action: 'auth.verifyEmailToken',
-        module: 'auth'
-    }),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        String
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], AuthEmailService.prototype, "verifyEmail", null);
-_ts_decorate([
-    (0, _nestjsshared.LogAction)({
-        action: 'auth.sendVerificationEmail',
-        module: 'auth'
-    }),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        String,
-        String
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], AuthEmailService.prototype, "resendVerificationEmail", null);
-AuthEmailService = _ts_decorate([
-    (0, _common.Injectable)({
-        scope: _common.Scope.REQUEST
-    }),
-    _ts_param(0, (0, _common.Optional)()),
-    _ts_param(0, (0, _common.Inject)(_authdatasourceprovider.AuthDataSourceProvider)),
-    _ts_param(1, (0, _common.Optional)()),
-    _ts_param(1, (0, _common.Inject)(_interfaces.AUTH_EMAIL_PROVIDER)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof _authdatasourceprovider.AuthDataSourceProvider === "undefined" ? Object : _authdatasourceprovider.AuthDataSourceProvider,
-        typeof _interfaces.IAuthEmailProvider === "undefined" ? Object : _interfaces.IAuthEmailProvider
-    ])
-], AuthEmailService);