Spaces:
Paused
Paused
| const UAParser = require('ua-parser-js'); | |
| /** | |
| * Device Info Service | |
| * Parses user agent and extracts device, browser, OS information | |
| * Also handles IP-based geolocation | |
| */ | |
| /** | |
| * Parse user agent string to extract device info | |
| * @param {string} userAgent - User agent string from request | |
| * @returns {Object} Parsed device information | |
| */ | |
| function parseUserAgent(userAgent) { | |
| if (!userAgent) { | |
| return { | |
| device: 'Unknown Device', | |
| browser: 'Unknown Browser', | |
| os: 'Unknown OS', | |
| userAgent: '' | |
| }; | |
| } | |
| const parser = new UAParser(userAgent); | |
| const result = parser.getResult(); | |
| // Format device name | |
| let device = 'Unknown Device'; | |
| if (result.device.vendor && result.device.model) { | |
| device = `${result.device.vendor} ${result.device.model}`; | |
| } else if (result.device.type) { | |
| device = result.device.type.charAt(0).toUpperCase() + result.device.type.slice(1); | |
| } else { | |
| // Infer from OS | |
| if (result.os.name?.toLowerCase().includes('android')) { | |
| device = 'Android Device'; | |
| } else if (result.os.name?.toLowerCase().includes('ios')) { | |
| device = 'iPhone/iPad'; | |
| } else if (result.os.name?.toLowerCase().includes('mac')) { | |
| device = 'Mac'; | |
| } else if (result.os.name?.toLowerCase().includes('windows')) { | |
| device = 'Windows PC'; | |
| } else if (result.os.name?.toLowerCase().includes('linux')) { | |
| device = 'Linux PC'; | |
| } else { | |
| device = 'Desktop'; | |
| } | |
| } | |
| // Format browser name with version | |
| let browser = 'Unknown Browser'; | |
| if (result.browser.name) { | |
| browser = result.browser.name; | |
| if (result.browser.version) { | |
| const majorVersion = result.browser.version.split('.')[0]; | |
| browser += ` ${majorVersion}`; | |
| } | |
| } | |
| // Format OS with version | |
| let os = 'Unknown OS'; | |
| if (result.os.name) { | |
| os = result.os.name; | |
| if (result.os.version) { | |
| os += ` ${result.os.version}`; | |
| } | |
| } | |
| return { | |
| device, | |
| browser, | |
| os, | |
| userAgent, | |
| raw: result | |
| }; | |
| } | |
| /** | |
| * Get client IP address from request | |
| * Handles proxies and load balancers | |
| * @param {Object} req - Express request object | |
| * @returns {string} Client IP address | |
| */ | |
| function getClientIP(req) { | |
| // Check various headers for proxied requests | |
| const forwardedFor = req.headers['x-forwarded-for']; | |
| if (forwardedFor) { | |
| // x-forwarded-for can contain multiple IPs, first one is client | |
| return forwardedFor.split(',')[0].trim(); | |
| } | |
| const realIP = req.headers['x-real-ip']; | |
| if (realIP) { | |
| return realIP.trim(); | |
| } | |
| const cfConnectingIP = req.headers['cf-connecting-ip']; // Cloudflare | |
| if (cfConnectingIP) { | |
| return cfConnectingIP.trim(); | |
| } | |
| // Fallback to socket remote address | |
| return req.socket?.remoteAddress || req.ip || 'Unknown'; | |
| } | |
| /** | |
| * Get geolocation from IP address using free IP-API service | |
| * Falls back gracefully if service is unavailable | |
| * @param {string} ipAddress - IP address to geolocate | |
| * @returns {Object} Location information | |
| */ | |
| async function getLocationFromIP(ipAddress) { | |
| const defaultLocation = { | |
| city: '', | |
| region: '', | |
| country: '', | |
| countryCode: '', | |
| formatted: 'Unknown Location', | |
| coordinates: { lat: null, lon: null } | |
| }; | |
| // Skip for localhost/private IPs | |
| if (!ipAddress || | |
| ipAddress === '::1' || | |
| ipAddress === '127.0.0.1' || | |
| ipAddress.startsWith('192.168.') || | |
| ipAddress.startsWith('10.') || | |
| ipAddress.startsWith('172.')) { | |
| return { ...defaultLocation, formatted: 'Local Network' }; | |
| } | |
| try { | |
| // Using ip-api.com (free, no API key needed, 45 req/min limit) | |
| const response = await fetch(`http://ip-api.com/json/${ipAddress}?fields=status,message,country,countryCode,region,regionName,city,lat,lon`, { | |
| signal: AbortSignal.timeout(3000) // 3 second timeout | |
| }); | |
| if (!response.ok) { | |
| return defaultLocation; | |
| } | |
| const data = await response.json(); | |
| if (data.status === 'fail') { | |
| return defaultLocation; | |
| } | |
| const location = { | |
| city: data.city || '', | |
| region: data.regionName || data.region || '', | |
| country: data.country || '', | |
| countryCode: data.countryCode || '', | |
| coordinates: { | |
| lat: data.lat || null, | |
| lon: data.lon || null | |
| } | |
| }; | |
| // Format location string | |
| const parts = [location.city, location.region, location.country].filter(Boolean); | |
| location.formatted = parts.length > 0 ? parts.join(', ') : 'Unknown Location'; | |
| return location; | |
| } catch (error) { | |
| console.error('Geolocation lookup failed:', error.message); | |
| return defaultLocation; | |
| } | |
| } | |
| /** | |
| * Get complete device info from request | |
| * Combines user agent parsing, IP extraction, and geolocation | |
| * @param {Object} req - Express request object | |
| * @returns {Object} Complete device information | |
| */ | |
| async function getDeviceInfo(req) { | |
| const userAgent = req.headers['user-agent'] || ''; | |
| const ipAddress = getClientIP(req); | |
| const deviceInfo = parseUserAgent(userAgent); | |
| const location = await getLocationFromIP(ipAddress); | |
| return { | |
| ...deviceInfo, | |
| ipAddress, | |
| location | |
| }; | |
| } | |
| /** | |
| * Synchronous version - skips geolocation | |
| * Use when you don't need location data immediately | |
| * @param {Object} req - Express request object | |
| * @returns {Object} Device information without location | |
| */ | |
| function getDeviceInfoSync(req) { | |
| const userAgent = req.headers['user-agent'] || ''; | |
| const ipAddress = getClientIP(req); | |
| const deviceInfo = parseUserAgent(userAgent); | |
| return { | |
| ...deviceInfo, | |
| ipAddress, | |
| location: { formatted: 'Loading...' } | |
| }; | |
| } | |
| /** | |
| * Format device info for display | |
| * @param {Object} deviceInfo - Device info object | |
| * @returns {string} Formatted string for display | |
| */ | |
| function formatDeviceInfo(deviceInfo) { | |
| const parts = []; | |
| if (deviceInfo.browser && deviceInfo.browser !== 'Unknown Browser') { | |
| parts.push(deviceInfo.browser); | |
| } | |
| if (deviceInfo.os && deviceInfo.os !== 'Unknown OS') { | |
| parts.push(`on ${deviceInfo.os}`); | |
| } | |
| return parts.length > 0 ? parts.join(' ') : 'Unknown Device'; | |
| } | |
| module.exports = { | |
| parseUserAgent, | |
| getClientIP, | |
| getLocationFromIP, | |
| getDeviceInfo, | |
| getDeviceInfoSync, | |
| formatDeviceInfo | |
| }; | |