@bhandari88/express-auth 1.0.0

package/dist/handlers/social-auth.d.ts

@@ -0,0 +1,15 @@
+import { UserRepository, AuthResult, AuthConfig } from '../types';
+import { JwtService } from '../utils/jwt';
+import passport from 'passport';
+export declare class SocialAuthHandler {
+    private userRepository;
+    private jwtService;
+    constructor(userRepository: UserRepository, jwtService: JwtService, config: AuthConfig);
+    private initializePassport;
+    handleSocialLogin(provider: 'google' | 'facebook', providerId: string, profile: {
+        email?: string;
+        name?: string;
+        photo?: string;
+    }): Promise<AuthResult>;
+    getPassport(): typeof passport;
+}

package/dist/handlers/social-auth.js

@@ -0,0 +1,164 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SocialAuthHandler = void 0;
+const validator_1 = require("../utils/validator");
+const passport_1 = __importDefault(require("passport"));
+const passport_google_oauth20_1 = require("passport-google-oauth20");
+const passport_facebook_1 = require("passport-facebook");
+class SocialAuthHandler {
+    constructor(userRepository, jwtService, config) {
+        this.userRepository = userRepository;
+        this.jwtService = jwtService;
+        this.initializePassport(config);
+    }
+    initializePassport(config) {
+        // Serialize user (minimal implementation for Passport compatibility)
+        passport_1.default.serializeUser((user, done) => {
+            done(null, user);
+        });
+        passport_1.default.deserializeUser((user, done) => {
+            done(null, user);
+        });
+        // Google Strategy
+        if (config.socialAuth?.google) {
+            passport_1.default.use(new passport_google_oauth20_1.Strategy({
+                clientID: config.socialAuth.google.clientID,
+                clientSecret: config.socialAuth.google.clientSecret,
+                callbackURL: config.socialAuth.google.callbackURL,
+            }, async (accessToken, refreshToken, profile, done) => {
+                try {
+                    const result = await this.handleSocialLogin('google', profile.id, {
+                        email: profile.emails?.[0]?.value,
+                        name: profile.displayName,
+                        photo: profile.photos?.[0]?.value,
+                    });
+                    if (result.success && result.user) {
+                        done(null, result.user);
+                    }
+                    else {
+                        done(new Error(result.error || 'Google authentication failed'), false);
+                    }
+                }
+                catch (error) {
+                    done(error, false);
+                }
+            }));
+        }
+        // Facebook Strategy
+        if (config.socialAuth?.facebook) {
+            passport_1.default.use(new passport_facebook_1.Strategy({
+                clientID: config.socialAuth.facebook.clientID,
+                clientSecret: config.socialAuth.facebook.clientSecret,
+                callbackURL: config.socialAuth.facebook.callbackURL,
+                profileFields: ['id', 'displayName', 'email', 'picture.type(large)'],
+            }, async (accessToken, refreshToken, profile, done) => {
+                try {
+                    const result = await this.handleSocialLogin('facebook', profile.id, {
+                        email: profile.emails?.[0]?.value,
+                        name: profile.displayName,
+                        photo: profile.photos?.[0]?.value,
+                    });
+                    if (result.success && result.user) {
+                        done(null, result.user);
+                    }
+                    else {
+                        done(new Error(result.error || 'Facebook authentication failed'), false);
+                    }
+                }
+                catch (error) {
+                    done(error, false);
+                }
+            }));
+        }
+    }
+    async handleSocialLogin(provider, providerId, profile) {
+        try {
+            // Find existing user by provider
+            let user = await this.userRepository.findByProvider(provider, providerId);
+            if (user) {
+                // User exists, generate tokens
+                const tokens = this.jwtService.generateTokens({
+                    userId: user.id || user._id || '',
+                    email: user.email,
+                    username: user.username,
+                    phone: user.phone,
+                });
+                const { password: _, ...userWithoutPassword } = user;
+                return {
+                    success: true,
+                    user: userWithoutPassword,
+                    tokens,
+                    message: 'Login successful',
+                };
+            }
+            // Check if user exists by email
+            if (profile.email) {
+                const sanitizedEmail = validator_1.ValidatorService.sanitizeEmail(profile.email);
+                user = await this.userRepository.findByEmail(sanitizedEmail);
+                if (user) {
+                    // Link social account to existing user
+                    await this.userRepository.update(user.id || user._id || '', {
+                        provider,
+                        providerId,
+                        verified: true,
+                    });
+                    const tokens = this.jwtService.generateTokens({
+                        userId: user.id || user._id || '',
+                        email: user.email,
+                        username: user.username,
+                        phone: user.phone,
+                    });
+                    const { password: _, ...userWithoutPassword } = user;
+                    return {
+                        success: true,
+                        user: userWithoutPassword,
+                        tokens,
+                        message: 'Account linked successfully',
+                    };
+                }
+            }
+            // Create new user
+            const userData = {
+                provider,
+                providerId,
+                verified: true,
+            };
+            if (profile.email) {
+                userData.email = validator_1.ValidatorService.sanitizeEmail(profile.email);
+            }
+            if (profile.name) {
+                userData.name = profile.name;
+            }
+            if (profile.photo) {
+                userData.photo = profile.photo;
+            }
+            user = await this.userRepository.create(userData);
+            const tokens = this.jwtService.generateTokens({
+                userId: user.id || user._id || '',
+                email: user.email,
+                username: user.username,
+                phone: user.phone,
+            });
+            const { password: _, ...userWithoutPassword } = user;
+            return {
+                success: true,
+                user: userWithoutPassword,
+                tokens,
+                message: 'Account created and logged in successfully',
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Social login failed',
+            };
+        }
+    }
+    getPassport() {
+        return passport_1.default;
+    }
+}
+exports.SocialAuthHandler = SocialAuthHandler;

package/dist/index.d.ts

@@ -0,0 +1,61 @@
+import { Express } from 'express';
+import { AuthConfig, UserRepository, LoginCredentials, RegisterData, AuthResult } from './types';
+import { JwtService } from './utils/jwt';
+import { PasswordService } from './utils/password';
+export declare class Auth {
+    private config;
+    private userRepository;
+    private jwtService;
+    private passwordService;
+    private localAuthHandler;
+    private socialAuthHandler?;
+    private middleware;
+    constructor(config: AuthConfig, userRepository: UserRepository);
+    /**
+     * Register a new user with email, username, or phone
+     */
+    register(data: RegisterData): Promise<AuthResult>;
+    /**
+     * Login with email, username, or phone and password
+     */
+    login(credentials: LoginCredentials): Promise<AuthResult>;
+    /**
+     * Change password for authenticated user
+     */
+    changePassword(userId: string, oldPassword: string, newPassword: string): Promise<AuthResult>;
+    /**
+     * Refresh access token using refresh token
+     */
+    refreshToken(refreshToken: string): Promise<AuthResult>;
+    /**
+     * Get authentication middleware for protected routes
+     */
+    getAuthMiddleware(): import("express").RequestHandler<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
+    /**
+     * Get optional authentication middleware (doesn't fail if no token)
+     */
+    getOptionalAuthMiddleware(): import("express").RequestHandler<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
+    /**
+     * Get role-based access control middleware
+     */
+    requireRole(roles: string[]): import("express").RequestHandler<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
+    /**
+     * Setup Express routes for authentication
+     */
+    setupRoutes(app: Express, basePath?: string): void;
+    /**
+     * Get the JWT service instance
+     */
+    getJwtService(): JwtService;
+    /**
+     * Get the password service instance
+     */
+    getPasswordService(): PasswordService;
+}
+export * from './types';
+export { JwtService } from './utils/jwt';
+export { PasswordService } from './utils/password';
+export { ValidatorService } from './utils/validator';
+export { AuthMiddleware } from './middleware/auth.middleware';
+export { LocalAuthHandler } from './handlers/local-auth';
+export { SocialAuthHandler } from './handlers/social-auth';

package/dist/index.js

@@ -0,0 +1,232 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SocialAuthHandler = exports.LocalAuthHandler = exports.AuthMiddleware = exports.ValidatorService = exports.PasswordService = exports.JwtService = exports.Auth = void 0;
+const jwt_1 = require("./utils/jwt");
+const password_1 = require("./utils/password");
+const local_auth_1 = require("./handlers/local-auth");
+const social_auth_1 = require("./handlers/social-auth");
+const auth_middleware_1 = require("./middleware/auth.middleware");
+class Auth {
+    constructor(config, userRepository) {
+        this.config = config;
+        this.userRepository = userRepository;
+        // Initialize services
+        this.jwtService = new jwt_1.JwtService(config);
+        this.passwordService = new password_1.PasswordService(config);
+        this.localAuthHandler = new local_auth_1.LocalAuthHandler(this.userRepository, this.jwtService, this.passwordService);
+        this.middleware = new auth_middleware_1.AuthMiddleware(this.jwtService, this.userRepository);
+        // Initialize social auth if configured
+        if (config.socialAuth) {
+            this.socialAuthHandler = new social_auth_1.SocialAuthHandler(this.userRepository, this.jwtService, config);
+        }
+    }
+    /**
+     * Register a new user with email, username, or phone
+     */
+    async register(data) {
+        return this.localAuthHandler.register(data);
+    }
+    /**
+     * Login with email, username, or phone and password
+     */
+    async login(credentials) {
+        return this.localAuthHandler.login(credentials);
+    }
+    /**
+     * Change password for authenticated user
+     */
+    async changePassword(userId, oldPassword, newPassword) {
+        return this.localAuthHandler.changePassword(userId, oldPassword, newPassword);
+    }
+    /**
+     * Refresh access token using refresh token
+     */
+    async refreshToken(refreshToken) {
+        try {
+            const decoded = this.jwtService.verifyRefreshToken(refreshToken);
+            const user = await this.userRepository.findById(decoded.userId);
+            if (!user) {
+                return { success: false, error: 'User not found' };
+            }
+            const tokens = this.jwtService.generateTokens({
+                userId: user.id || user._id || '',
+                email: user.email,
+                username: user.username,
+                phone: user.phone,
+            });
+            return {
+                success: true,
+                tokens,
+                message: 'Token refreshed successfully',
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Token refresh failed',
+            };
+        }
+    }
+    /**
+     * Get authentication middleware for protected routes
+     */
+    getAuthMiddleware() {
+        return this.middleware.authenticate;
+    }
+    /**
+     * Get optional authentication middleware (doesn't fail if no token)
+     */
+    getOptionalAuthMiddleware() {
+        return this.middleware.optional;
+    }
+    /**
+     * Get role-based access control middleware
+     */
+    requireRole(roles) {
+        return this.middleware.requireRole(roles);
+    }
+    /**
+     * Setup Express routes for authentication
+     */
+    setupRoutes(app, basePath = '/api/auth') {
+        // Local authentication routes
+        app.post(`${basePath}/register`, async (req, res) => {
+            const result = await this.register(req.body);
+            if (result.success) {
+                res.status(201).json(result);
+            }
+            else {
+                res.status(400).json(result);
+            }
+        });
+        app.post(`${basePath}/login`, async (req, res) => {
+            const result = await this.login(req.body);
+            if (result.success) {
+                res.status(200).json(result);
+            }
+            else {
+                res.status(401).json(result);
+            }
+        });
+        app.post(`${basePath}/refresh`, async (req, res) => {
+            const { refreshToken } = req.body;
+            if (!refreshToken) {
+                res.status(400).json({ success: false, error: 'Refresh token is required' });
+                return;
+            }
+            const result = await this.refreshToken(refreshToken);
+            if (result.success) {
+                res.status(200).json(result);
+            }
+            else {
+                res.status(401).json(result);
+            }
+        });
+        app.post(`${basePath}/change-password`, this.getAuthMiddleware(), async (req, res) => {
+            const authReq = req;
+            const { oldPassword, newPassword } = req.body;
+            if (!oldPassword || !newPassword) {
+                res.status(400).json({
+                    success: false,
+                    error: 'Old password and new password are required',
+                });
+                return;
+            }
+            const userId = authReq.user?.id || authReq.user?._id || '';
+            const result = await this.changePassword(userId, oldPassword, newPassword);
+            if (result.success) {
+                res.status(200).json(result);
+            }
+            else {
+                res.status(400).json(result);
+            }
+        });
+        // Social authentication routes
+        if (this.socialAuthHandler) {
+            const passport = this.socialAuthHandler.getPassport();
+            // Google routes
+            if (this.config.socialAuth?.google) {
+                app.get(`${basePath}/google`, passport.authenticate('google', { scope: ['profile', 'email'] }));
+                app.get(`${basePath}/google/callback`, passport.authenticate('google', { session: false }), async (req, res) => {
+                    const user = req.user;
+                    if (user && (user.id || user._id)) {
+                        const tokens = this.jwtService.generateTokens({
+                            userId: user.id || user._id || '',
+                            email: user.email,
+                            username: user.username,
+                            phone: user.phone,
+                        });
+                        // Remove password from user response
+                        const { password: _, ...userWithoutPassword } = user;
+                        res.json({ success: true, user: userWithoutPassword, tokens });
+                    }
+                    else {
+                        res.status(401).json({ success: false, error: 'Google authentication failed' });
+                    }
+                });
+            }
+            // Facebook routes
+            if (this.config.socialAuth?.facebook) {
+                app.get(`${basePath}/facebook`, passport.authenticate('facebook', { scope: ['email'] }));
+                app.get(`${basePath}/facebook/callback`, passport.authenticate('facebook', { session: false }), async (req, res) => {
+                    const user = req.user;
+                    if (user && (user.id || user._id)) {
+                        const tokens = this.jwtService.generateTokens({
+                            userId: user.id || user._id || '',
+                            email: user.email,
+                            username: user.username,
+                            phone: user.phone,
+                        });
+                        // Remove password from user response
+                        const { password: _, ...userWithoutPassword } = user;
+                        res.json({ success: true, user: userWithoutPassword, tokens });
+                    }
+                    else {
+                        res.status(401).json({ success: false, error: 'Facebook authentication failed' });
+                    }
+                });
+            }
+        }
+    }
+    /**
+     * Get the JWT service instance
+     */
+    getJwtService() {
+        return this.jwtService;
+    }
+    /**
+     * Get the password service instance
+     */
+    getPasswordService() {
+        return this.passwordService;
+    }
+}
+exports.Auth = Auth;
+// Export types and classes
+__exportStar(require("./types"), exports);
+var jwt_2 = require("./utils/jwt");
+Object.defineProperty(exports, "JwtService", { enumerable: true, get: function () { return jwt_2.JwtService; } });
+var password_2 = require("./utils/password");
+Object.defineProperty(exports, "PasswordService", { enumerable: true, get: function () { return password_2.PasswordService; } });
+var validator_1 = require("./utils/validator");
+Object.defineProperty(exports, "ValidatorService", { enumerable: true, get: function () { return validator_1.ValidatorService; } });
+var auth_middleware_2 = require("./middleware/auth.middleware");
+Object.defineProperty(exports, "AuthMiddleware", { enumerable: true, get: function () { return auth_middleware_2.AuthMiddleware; } });
+var local_auth_2 = require("./handlers/local-auth");
+Object.defineProperty(exports, "LocalAuthHandler", { enumerable: true, get: function () { return local_auth_2.LocalAuthHandler; } });
+var social_auth_2 = require("./handlers/social-auth");
+Object.defineProperty(exports, "SocialAuthHandler", { enumerable: true, get: function () { return social_auth_2.SocialAuthHandler; } });

package/dist/middleware/auth.middleware.d.ts

@@ -0,0 +1,11 @@
+import { RequestHandler } from 'express';
+import { UserRepository } from '../types';
+import { JwtService } from '../utils/jwt';
+export declare class AuthMiddleware {
+    private jwtService;
+    private userRepository;
+    constructor(jwtService: JwtService, userRepository: UserRepository);
+    authenticate: RequestHandler;
+    optional: RequestHandler;
+    requireRole: (roles: string[]) => RequestHandler;
+}

package/dist/middleware/auth.middleware.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthMiddleware = void 0;
+class AuthMiddleware {
+    constructor(jwtService, userRepository) {
+        this.jwtService = jwtService;
+        this.userRepository = userRepository;
+        this.authenticate = async (req, res, next) => {
+            const authReq = req;
+            try {
+                // Get token from Authorization header
+                const authHeader = req.headers.authorization;
+                if (!authHeader || !authHeader.startsWith('Bearer ')) {
+                    res.status(401).json({
+                        success: false,
+                        error: 'No token provided. Please include a valid JWT token in the Authorization header.',
+                    });
+                    return;
+                }
+                const token = authHeader.substring(7); // Remove 'Bearer ' prefix
+                // Verify token
+                let decoded;
+                try {
+                    decoded = this.jwtService.verifyAccessToken(token);
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : 'Invalid token';
+                    res.status(401).json({
+                        success: false,
+                        error: message,
+                    });
+                    return;
+                }
+                // Find user
+                const user = await this.userRepository.findById(decoded.userId);
+                if (!user) {
+                    res.status(401).json({
+                        success: false,
+                        error: 'User not found. Token may be invalid.',
+                    });
+                    return;
+                }
+                // Attach user to request
+                authReq.user = user;
+                next();
+            }
+            catch (error) {
+                res.status(500).json({
+                    success: false,
+                    error: 'Authentication error',
+                });
+            }
+        };
+        this.optional = async (req, res, next) => {
+            try {
+                const authReq = req;
+                const authHeader = req.headers.authorization;
+                if (authHeader && authHeader.startsWith('Bearer ')) {
+                    const token = authHeader.substring(7);
+                    try {
+                        const decoded = this.jwtService.verifyAccessToken(token);
+                        const user = await this.userRepository.findById(decoded.userId);
+                        if (user) {
+                            authReq.user = user;
+                        }
+                    }
+                    catch (error) {
+                        // Token invalid, but continue without user
+                    }
+                }
+                next();
+            }
+            catch (error) {
+                // Continue even if there's an error
+                next();
+            }
+        };
+        // Role-based access control helper
+        this.requireRole = (roles) => {
+            return (req, res, next) => {
+                const authReq = req;
+                if (!authReq.user) {
+                    res.status(401).json({
+                        success: false,
+                        error: 'Authentication required',
+                    });
+                    return;
+                }
+                const userRole = authReq.user.role || 'user';
+                if (!roles.includes(userRole)) {
+                    res.status(403).json({
+                        success: false,
+                        error: 'Insufficient permissions',
+                    });
+                    return;
+                }
+                next();
+            };
+        };
+    }
+}
+exports.AuthMiddleware = AuthMiddleware;

package/dist/types/index.d.ts

@@ -0,0 +1,84 @@
+import { Request } from 'express';
+export interface AuthConfig {
+    jwtSecret: string;
+    jwtExpiresIn?: string;
+    refreshTokenSecret?: string;
+    refreshTokenExpiresIn?: string;
+    bcryptRounds?: number;
+    enableRefreshTokens?: boolean;
+    socialAuth?: {
+        google?: {
+            clientID: string;
+            clientSecret: string;
+            callbackURL: string;
+        };
+        facebook?: {
+            clientID: string;
+            clientSecret: string;
+            callbackURL: string;
+        };
+    };
+}
+export interface User {
+    id: string;
+    email?: string;
+    username?: string;
+    phone?: string;
+    password?: string;
+    provider?: 'local' | 'google' | 'facebook';
+    providerId?: string;
+    verified?: boolean;
+    createdAt?: Date;
+    updatedAt?: Date;
+    [key: string]: any;
+}
+export interface UserDocument extends User {
+    _id?: string;
+}
+export interface AuthTokens {
+    accessToken: string;
+    refreshToken?: string;
+    expiresIn: number;
+}
+export interface LoginCredentials {
+    email?: string;
+    username?: string;
+    phone?: string;
+    password: string;
+}
+export interface RegisterData {
+    email?: string;
+    username?: string;
+    phone?: string;
+    password: string;
+    [key: string]: any;
+}
+export interface AuthResult {
+    success: boolean;
+    user?: User;
+    tokens?: AuthTokens;
+    message?: string;
+    error?: string;
+}
+export interface UserRepository {
+    findById(id: string): Promise<UserDocument | null>;
+    findByEmail(email: string): Promise<UserDocument | null>;
+    findByUsername(username: string): Promise<UserDocument | null>;
+    findByPhone(phone: string): Promise<UserDocument | null>;
+    findByProvider(provider: string, providerId: string): Promise<UserDocument | null>;
+    create(userData: Partial<User>): Promise<UserDocument>;
+    update(id: string, updateData: Partial<User>): Promise<UserDocument | null>;
+    delete(id: string): Promise<boolean>;
+}
+export interface AuthRequest extends Request {
+    user?: UserDocument;
+}
+export interface JwtPayload {
+    userId: string;
+    email?: string;
+    username?: string;
+    phone?: string;
+    type?: 'access' | 'refresh';
+    iat?: number;
+    exp?: number;
+}

package/dist/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/index.d.ts

@@ -0,0 +1,3 @@
+export { JwtService } from './jwt';
+export { PasswordService } from './password';
+export { ValidatorService } from './validator';