@ciscode/authentication-kit 1.4.1 → 1.4.2

package/dist/auth-kit.module.js

@@ -22,6 +22,7 @@ const auth_controller_1 = require("./controllers/auth.controller");
 const users_controller_1 = require("./controllers/users.controller");
 const roles_controller_1 = require("./controllers/roles.controller");
 const permissions_controller_1 = require("./controllers/permissions.controller");
+const health_controller_1 = require("./controllers/health.controller");
 const user_model_1 = require("./models/user.model");
 const role_model_1 = require("./models/role.model");
 const permission_model_1 = require("./models/permission.model");
@@ -70,6 +71,7 @@ exports.AuthKitModule = AuthKitModule = __decorate([
             users_controller_1.UsersController,
             roles_controller_1.RolesController,
             permissions_controller_1.PermissionsController,
+            health_controller_1.HealthController,
         ],
         providers: [
             {

package/dist/controllers/health.controller.d.ts

@@ -0,0 +1,48 @@
+import { MailService } from '../services/mail.service';
+import { LoggerService } from '../services/logger.service';
+export declare class HealthController {
+    private readonly mail;
+    private readonly logger;
+    constructor(mail: MailService, logger: LoggerService);
+    checkSmtp(): Promise<{
+        config: {
+            host: string;
+            port: string;
+            secure: string;
+            user: string;
+            fromEmail: string;
+        };
+        error: string;
+        service: string;
+        status: string;
+    } | {
+        service: string;
+        status: string;
+        error: any;
+    }>;
+    checkAll(): Promise<{
+        status: string;
+        checks: {
+            smtp: {
+                config: {
+                    host: string;
+                    port: string;
+                    secure: string;
+                    user: string;
+                    fromEmail: string;
+                };
+                error: string;
+                service: string;
+                status: string;
+            } | {
+                service: string;
+                status: string;
+                error: any;
+            };
+        };
+        environment: {
+            nodeEnv: string;
+            frontendUrl: string;
+        };
+    }>;
+}

package/dist/controllers/health.controller.js

@@ -0,0 +1,77 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HealthController = void 0;
+const common_1 = require("@nestjs/common");
+const mail_service_1 = require("../services/mail.service");
+const logger_service_1 = require("../services/logger.service");
+let HealthController = class HealthController {
+    constructor(mail, logger) {
+        this.mail = mail;
+        this.logger = logger;
+    }
+    async checkSmtp() {
+        try {
+            const result = await this.mail.verifyConnection();
+            return {
+                service: 'smtp',
+                status: result.connected ? 'connected' : 'disconnected',
+                ...(result.error && { error: result.error }),
+                config: {
+                    host: process.env.SMTP_HOST || 'not set',
+                    port: process.env.SMTP_PORT || 'not set',
+                    secure: process.env.SMTP_SECURE || 'not set',
+                    user: process.env.SMTP_USER ? '***' + process.env.SMTP_USER.slice(-4) : 'not set',
+                    fromEmail: process.env.FROM_EMAIL || 'not set',
+                }
+            };
+        }
+        catch (error) {
+            this.logger.error(`SMTP health check failed: ${error.message}`, error.stack, 'HealthController');
+            return {
+                service: 'smtp',
+                status: 'error',
+                error: error.message
+            };
+        }
+    }
+    async checkAll() {
+        const smtp = await this.checkSmtp();
+        return {
+            status: smtp.status === 'connected' ? 'healthy' : 'degraded',
+            checks: {
+                smtp
+            },
+            environment: {
+                nodeEnv: process.env.NODE_ENV || 'not set',
+                frontendUrl: process.env.FRONTEND_URL || 'not set',
+            }
+        };
+    }
+};
+exports.HealthController = HealthController;
+__decorate([
+    (0, common_1.Get)('smtp'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], HealthController.prototype, "checkSmtp", null);
+__decorate([
+    (0, common_1.Get)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], HealthController.prototype, "checkAll", null);
+exports.HealthController = HealthController = __decorate([
+    (0, common_1.Controller)('api/health'),
+    __metadata("design:paramtypes", [mail_service_1.MailService,
+        logger_service_1.LoggerService])
+], HealthController);

package/dist/services/auth.service.d.ts

@@ -26,8 +26,12 @@ export declare class AuthService {
         data: any;
     }>;
     register(dto: RegisterDto): Promise<{
+        emailError: string;
+        emailHint: string;
+        ok: boolean;
         id: any;
         email: string;
+        emailSent: boolean;
     }>;
     verifyEmail(token: string): Promise<{
         ok: boolean;
@@ -36,6 +40,23 @@ export declare class AuthService {
     resendVerification(email: string): Promise<{
         ok: boolean;
         message: string;
+        emailSent?: undefined;
+        error?: undefined;
+    } | {
+        ok: boolean;
+        message: string;
+        emailSent: boolean;
+        error?: undefined;
+    } | {
+        ok: boolean;
+        message: string;
+        emailSent: boolean;
+        error: any;
+    } | {
+        ok: boolean;
+        message: string;
+        error: any;
+        emailSent?: undefined;
     }>;
     login(dto: LoginDto): Promise<{
         accessToken: string;
@@ -48,6 +69,23 @@ export declare class AuthService {
     forgotPassword(email: string): Promise<{
         ok: boolean;
         message: string;
+        emailSent?: undefined;
+        error?: undefined;
+    } | {
+        ok: boolean;
+        message: string;
+        emailSent: boolean;
+        error?: undefined;
+    } | {
+        ok: boolean;
+        message: string;
+        emailSent: boolean;
+        error: any;
+    } | {
+        ok: boolean;
+        message: string;
+        error: any;
+        emailSent?: undefined;
     }>;
     resetPassword(token: string, newPassword: string): Promise<{
         ok: boolean;

package/dist/services/auth.service.js

@@ -185,15 +185,25 @@ let AuthService = class AuthService {
                 passwordChangedAt: new Date()
             });
             // Send verification email (don't let email failures crash registration)
+            let emailSent = true;
+            let emailError;
             try {
                 const emailToken = this.signEmailToken({ sub: user._id.toString(), purpose: 'verify' });
                 await this.mail.sendVerificationEmail(user.email, emailToken);
             }
             catch (error) {
+                emailSent = false;
+                emailError = error.message || 'Failed to send verification email';
                 this.logger.error(`Failed to send verification email: ${error.message}`, error.stack, 'AuthService');
                 // Continue - user is created, they can resend verification
             }
-            return { id: user._id, email: user.email };
+            return {
+                ok: true,
+                id: user._id,
+                email: user.email,
+                emailSent,
+                ...(emailError && { emailError, emailHint: 'User created successfully. You can resend verification email later.' })
+            };
         }
         catch (error) {
             // Re-throw HTTP exceptions
@@ -247,13 +257,29 @@ let AuthService = class AuthService {
                 return { ok: true, message: 'If the email exists and is unverified, a verification email has been sent' };
             }
             const emailToken = this.signEmailToken({ sub: user._id.toString(), purpose: 'verify' });
-            await this.mail.sendVerificationEmail(user.email, emailToken);
-            return { ok: true, message: 'Verification email sent successfully' };
+            try {
+                await this.mail.sendVerificationEmail(user.email, emailToken);
+                return { ok: true, message: 'Verification email sent successfully', emailSent: true };
+            }
+            catch (emailError) {
+                // Log the actual error but return generic message
+                this.logger.error(`Failed to send verification email: ${emailError.message}`, emailError.stack, 'AuthService');
+                return {
+                    ok: false,
+                    message: 'Failed to send verification email',
+                    emailSent: false,
+                    error: emailError.message || 'Email service error'
+                };
+            }
         }
         catch (error) {
             this.logger.error(`Resend verification failed: ${error.message}`, error.stack, 'AuthService');
-            // Return success to prevent email enumeration
-            return { ok: true, message: 'If the email exists and is unverified, a verification email has been sent' };
+            // Return error details for debugging
+            return {
+                ok: false,
+                message: 'Failed to resend verification email',
+                error: error.message
+            };
         }
     }
     async login(dto) {
@@ -328,17 +354,36 @@ let AuthService = class AuthService {
     async forgotPassword(email) {
         try {
             const user = await this.users.findByEmail(email);
-            // Always return success to prevent email enumeration
+            // Always return success to prevent email enumeration (in production)
             if (!user) {
                 return { ok: true, message: 'If the email exists, a password reset link has been sent' };
             }
             const resetToken = this.signResetToken({ sub: user._id.toString(), purpose: 'reset' });
-            await this.mail.sendPasswordResetEmail(user.email, resetToken);
-            return { ok: true, message: 'Password reset link sent successfully' };
+            try {
+                await this.mail.sendPasswordResetEmail(user.email, resetToken);
+                return { ok: true, message: 'Password reset link sent successfully', emailSent: true };
+            }
+            catch (emailError) {
+                // Log the actual error but return generic message for security
+                this.logger.error(`Failed to send reset email: ${emailError.message}`, emailError.stack, 'AuthService');
+                // In development, return error details; in production, hide for security
+                if (process.env.NODE_ENV === 'development') {
+                    return {
+                        ok: false,
+                        message: 'Failed to send password reset email',
+                        emailSent: false,
+                        error: emailError.message
+                    };
+                }
+                return { ok: true, message: 'If the email exists, a password reset link has been sent' };
+            }
         }
         catch (error) {
             this.logger.error(`Forgot password failed: ${error.message}`, error.stack, 'AuthService');
-            // Return success to prevent email enumeration
+            // In development, return error; in production, hide for security
+            if (process.env.NODE_ENV === 'development') {
+                return { ok: false, message: 'Failed to process password reset', error: error.message };
+            }
             return { ok: true, message: 'If the email exists, a password reset link has been sent' };
         }
     }

package/dist/services/mail.service.d.ts

@@ -2,7 +2,14 @@ import { LoggerService } from './logger.service';
 export declare class MailService {
     private readonly logger;
     private transporter;
+    private smtpConfigured;
     constructor(logger: LoggerService);
+    private initializeTransporter;
+    verifyConnection(): Promise<{
+        connected: boolean;
+        error?: string;
+    }>;
     sendVerificationEmail(email: string, token: string): Promise<void>;
     sendPasswordResetEmail(email: string, token: string): Promise<void>;
+    private getDetailedSmtpError;
 }

package/dist/services/mail.service.js

@@ -19,17 +19,56 @@ const logger_service_1 = require("./logger.service");
 let MailService = class MailService {
     constructor(logger) {
         this.logger = logger;
-        this.transporter = nodemailer_1.default.createTransport({
-            host: process.env.SMTP_HOST,
-            port: parseInt(process.env.SMTP_PORT, 10),
-            secure: process.env.SMTP_SECURE === 'true',
-            auth: {
-                user: process.env.SMTP_USER,
-                pass: process.env.SMTP_PASS
+        this.smtpConfigured = false;
+        this.initializeTransporter();
+    }
+    initializeTransporter() {
+        try {
+            // Check if SMTP is configured
+            if (!process.env.SMTP_HOST || !process.env.SMTP_PORT) {
+                this.logger.warn('SMTP not configured - email functionality will be disabled', 'MailService');
+                this.smtpConfigured = false;
+                return;
             }
-        });
+            this.transporter = nodemailer_1.default.createTransport({
+                host: process.env.SMTP_HOST,
+                port: parseInt(process.env.SMTP_PORT, 10),
+                secure: process.env.SMTP_SECURE === 'true',
+                auth: {
+                    user: process.env.SMTP_USER,
+                    pass: process.env.SMTP_PASS
+                },
+                connectionTimeout: 10000, // 10 seconds
+                greetingTimeout: 10000,
+            });
+            this.smtpConfigured = true;
+        }
+        catch (error) {
+            this.logger.error(`Failed to initialize SMTP transporter: ${error.message}`, error.stack, 'MailService');
+            this.smtpConfigured = false;
+        }
+    }
+    async verifyConnection() {
+        if (!this.smtpConfigured) {
+            return { connected: false, error: 'SMTP not configured' };
+        }
+        try {
+            await this.transporter.verify();
+            this.logger.log('SMTP connection verified successfully', 'MailService');
+            return { connected: true };
+        }
+        catch (error) {
+            const errorMsg = `SMTP connection failed: ${error.message}`;
+            this.logger.error(errorMsg, error.stack, 'MailService');
+            return { connected: false, error: errorMsg };
+        }
     }
     async sendVerificationEmail(email, token) {
+        if (!this.smtpConfigured) {
+            const error = new common_1.InternalServerErrorException('SMTP not configured - cannot send emails');
+            this.logger.error('Attempted to send email but SMTP is not configured', '', 'MailService');
+            throw error;
+        }
         try {
             const url = `${process.env.FRONTEND_URL}/confirm-email?token=${token}`;
             await this.transporter.sendMail({
@@ -42,11 +81,17 @@ let MailService = class MailService {
             this.logger.log(`Verification email sent to ${email}`, 'MailService');
         }
         catch (error) {
-            this.logger.error(`Failed to send verification email to ${email}: ${error.message}`, error.stack, 'MailService');
-            throw error; // Re-throw so caller can handle
+            const detailedError = this.getDetailedSmtpError(error);
+            this.logger.error(`Failed to send verification email to ${email}: ${detailedError}`, error.stack, 'MailService');
+            throw new common_1.InternalServerErrorException(detailedError);
         }
     }
     async sendPasswordResetEmail(email, token) {
+        if (!this.smtpConfigured) {
+            const error = new common_1.InternalServerErrorException('SMTP not configured - cannot send emails');
+            this.logger.error('Attempted to send email but SMTP is not configured', '', 'MailService');
+            throw error;
+        }
         try {
             const url = `${process.env.FRONTEND_URL}/reset-password?token=${token}`;
             await this.transporter.sendMail({
@@ -59,9 +104,28 @@ let MailService = class MailService {
             this.logger.log(`Password reset email sent to ${email}`, 'MailService');
         }
         catch (error) {
-            this.logger.error(`Failed to send password reset email to ${email}: ${error.message}`, error.stack, 'MailService');
-            throw error; // Re-throw so caller can handle
+            const detailedError = this.getDetailedSmtpError(error);
+            this.logger.error(`Failed to send password reset email to ${email}: ${detailedError}`, error.stack, 'MailService');
+            throw new common_1.InternalServerErrorException(detailedError);
+        }
+    }
+    getDetailedSmtpError(error) {
+        if (error.code === 'EAUTH') {
+            return 'SMTP authentication failed. Check SMTP_USER and SMTP_PASS environment variables.';
+        }
+        if (error.code === 'ESOCKET' || error.code === 'ECONNECTION') {
+            return `Cannot connect to SMTP server at ${process.env.SMTP_HOST}:${process.env.SMTP_PORT}. Check network/firewall settings.`;
+        }
+        if (error.code === 'ETIMEDOUT' || error.code === 'ECONNABORTED') {
+            return 'SMTP connection timed out. Server may be unreachable or firewalled.';
+        }
+        if (error.responseCode >= 500) {
+            return `SMTP server error (${error.responseCode}): ${error.response}`;
+        }
+        if (error.responseCode >= 400) {
+            return `SMTP client error (${error.responseCode}): Check FROM_EMAIL and recipient addresses.`;
         }
+        return error.message || 'Unknown SMTP error';
     }
 };
 exports.MailService = MailService;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ciscode/authentication-kit",
-  "version": "1.4.1",
+  "version": "1.4.2",
   "description": "NestJS auth kit with local + OAuth, JWT, RBAC, password reset.",
   "publishConfig": {
     "access": "public"