feat: geo-device-service, Weather по геопозиции, Discover вкладка GooSeek

Geo Device Service:
- Новый сервис определения геопозиции, устройства, браузера
- geoip-lite, ua-parser-js, CORS
- GET/POST /api/context

Frontend:
- /api/geo-context — прокси к geo-device, fallback при недоступности
- geoDevice.ts — fetchContextWithClient, fetchContextWithGeolocation
- Weather: геопозиция через geo-device + GeoJS + ipwhois fallback
- Weather API: поддержка city (геокодинг Open-Meteo)
- Discover: вкладка GooSeek по умолчанию

Документация:
- MICROSERVICES.md — секция 3.9 Geo Device Service

Co-authored-by: Cursor <cursoragent@cursor.com>

apps/geo-device-service/.gitignore

@@ -0,0 +1,5 @@
+node_modules/
+dist/
+.env
+*.log
+.DS_Store

apps/geo-device-service/README.md

@@ -0,0 +1,57 @@
+# Geo Device Service
+
+Сервис определения геопозиции, устройства и браузера пользователя.
+
+## Возможности
+
+- **Геолокация по IP** — offline lookup через geoip-lite (MaxMind GeoLite)
+- **Device** — тип (desktop/mobile/tablet), vendor, model
+- **Browser** — имя, версия
+- **OS** — операционная система и версия
+- **Client context** — при POST с body: screen size, timezone, language, hardwareConcurrency, deviceMemory, doNotTrack
+
+## API
+
+### GET /api/context
+
+Возвращает контекст на основе IP и заголовков запроса.
+
+### POST /api/context
+
+Принимает дополнительные данные от клиента (geo из Geolocation API, размер экрана, timezone и т.д.) и объединяет с серверными данными.
+
+**Body:**
+```json
+{
+  "geo": {
+    "latitude": 55.7558,
+    "longitude": 37.6173,
+    "city": "Moscow",
+    "country": "Russia",
+    "timezone": "Europe/Moscow"
+  },
+  "client": {
+    "screenWidth": 1920,
+    "screenHeight": 1080,
+    "viewportWidth": 1920,
+    "viewportHeight": 969,
+    "devicePixelRatio": 2,
+    "timezone": "Europe/Moscow",
+    "language": "en",
+    "languages": ["en", "ru"],
+    "platform": "MacIntel",
+    "hardwareConcurrency": 8,
+    "deviceMemory": 8,
+    "cookieEnabled": true,
+    "doNotTrack": null
+  }
+}
+```
+
+## Запуск
+
+```bash
+npm run dev
+# или
+PORT=4002 npm start
+```

apps/geo-device-service/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "geo-device-service",
+  "version": "1.0.0",
+  "type": "module",
+  "description": "Сервис определения геопозиции, устройства и браузера пользователя",
+  "main": "src/index.ts",
+  "scripts": {
+    "dev": "npx tsx watch src/index.ts",
+    "start": "npx tsx src/index.ts"
+  },
+  "dependencies": {
+    "cors": "^2.8.5",
+    "express": "^4.21.0",
+    "geoip-lite": "^1.4.9",
+    "ua-parser-js": "^1.0.41"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.21",
+    "@types/ua-parser-js": "^0.7.39",
+    "tsx": "^4.19.0",
+    "typescript": "^5.9.3"
+  }
+}

apps/geo-device-service/src/index.ts

@@ -0,0 +1,20 @@
+import express from 'express';
+import cors from 'cors';
+import contextRouter from './routes/context.js';
+
+const app = express();
+
+app.use(cors({ origin: true }));
+const PORT = process.env.PORT || 4002;
+
+app.use(express.json({ limit: '1mb' }));
+
+app.use('/api', contextRouter);
+
+app.get('/health', (_, res) => res.json({ status: 'ok', service: 'geo-device' }));
+
+app.listen(PORT, () => {
+  console.log(`Geo Device Service: http://localhost:${PORT}`);
+  console.log(`  Context (GET):  /api/context`);
+  console.log(`  Context (POST): /api/context (with client data in body)`);
+});

apps/geo-device-service/src/lib/context.ts

@@ -0,0 +1,69 @@
+import type { GeoDeviceContext, GeoLocation, ClientContext } from '../types.js';
+import { lookupByIP } from './geo.js';
+import { parseUserAgent } from './device.js';
+
+const getClientIP = (req: { headers: Record<string, string | string[] | undefined> }): string => {
+  const forwarded = req.headers['x-forwarded-for'];
+  if (typeof forwarded === 'string') {
+    return forwarded.split(',')[0].trim();
+  }
+  if (Array.isArray(forwarded)) {
+    return (forwarded[0] ?? '').split(',')[0].trim();
+  }
+  return (req.headers['x-real-ip'] as string) ?? '';
+};
+
+export const buildContext = (
+  req: { headers: Record<string, string | string[] | undefined>; socket?: { remoteAddress?: string } },
+  clientData?: Partial<{
+    geo: Partial<GeoLocation>;
+    client: Partial<ClientContext>;
+  }>,
+): GeoDeviceContext => {
+  const ip = getClientIP(req) || req.socket?.remoteAddress?.replace(/^::ffff:/, '') || '';
+  const userAgent = (req.headers['user-agent'] as string) ?? '';
+  const acceptLanguage = (req.headers['accept-language'] as string) ?? undefined;
+
+  const { device, browser, os } = parseUserAgent(userAgent);
+
+  let geo: GeoLocation | null = clientData?.geo
+    ? {
+        latitude: clientData.geo.latitude ?? 0,
+        longitude: clientData.geo.longitude ?? 0,
+        country: clientData.geo.country ?? '',
+        countryCode: clientData.geo.countryCode ?? '',
+        region: clientData.geo.region ?? '',
+        city: clientData.geo.city ?? '',
+        timezone: clientData.geo.timezone ?? '',
+        source: 'client',
+      }
+    : lookupByIP(ip);
+
+  const client: ClientContext = {
+    screenWidth: clientData?.client?.screenWidth,
+    screenHeight: clientData?.client?.screenHeight,
+    viewportWidth: clientData?.client?.viewportWidth,
+    viewportHeight: clientData?.client?.viewportHeight,
+    devicePixelRatio: clientData?.client?.devicePixelRatio,
+    timezone: clientData?.client?.timezone,
+    language: clientData?.client?.language,
+    languages: clientData?.client?.languages,
+    platform: clientData?.client?.platform,
+    hardwareConcurrency: clientData?.client?.hardwareConcurrency,
+    deviceMemory: clientData?.client?.deviceMemory,
+    cookieEnabled: clientData?.client?.cookieEnabled,
+    doNotTrack: clientData?.client?.doNotTrack,
+  };
+
+  return {
+    geo,
+    device,
+    browser,
+    os,
+    client,
+    ip: ip || undefined,
+    userAgent,
+    acceptLanguage,
+    requestedAt: new Date().toISOString(),
+  };
+};

apps/geo-device-service/src/lib/device.ts

@@ -0,0 +1,35 @@
+import UAParser from 'ua-parser-js';
+import type { DeviceInfo, BrowserInfo, OSInfo } from '../types.js';
+
+export const parseUserAgent = (ua: string): {
+  device: DeviceInfo;
+  browser: BrowserInfo;
+  os: OSInfo;
+} => {
+  const parser = new UAParser(ua);
+  const result = parser.getResult();
+
+  const deviceType = result.device.type as DeviceInfo['type'] | undefined;
+  const type: DeviceInfo['type'] =
+    deviceType && ['mobile', 'tablet', 'wearable', 'smarttv', 'desktop'].includes(deviceType)
+      ? deviceType
+      : 'desktop';
+
+  return {
+    device: {
+      type,
+      vendor: result.device.vendor || undefined,
+      model: result.device.model || undefined,
+    },
+    browser: {
+      name: result.browser.name ?? 'Unknown',
+      version: result.browser.version ?? '',
+      full: [result.browser.name, result.browser.version].filter(Boolean).join(' '),
+    },
+    os: {
+      name: result.os.name ?? 'Unknown',
+      version: result.os.version ?? '',
+      full: [result.os.name, result.os.version].filter(Boolean).join(' '),
+    },
+  };
+};

apps/geo-device-service/src/lib/geo.ts

@@ -0,0 +1,22 @@
+import geoip from 'geoip-lite';
+import type { GeoLocation } from '../types.js';
+
+export const lookupByIP = (ip: string): GeoLocation | null => {
+  if (!ip || ip === '::1' || ip === '127.0.0.1') {
+    return null;
+  }
+
+  const result = geoip.lookup(ip);
+  if (!result) return null;
+
+  return {
+    latitude: result.ll?.[0] ?? 0,
+    longitude: result.ll?.[1] ?? 0,
+    country: result.country ?? '',
+    countryCode: result.country ?? '',
+    region: result.region ?? '',
+    city: result.city ?? '',
+    timezone: result.timezone ?? '',
+    source: 'ip',
+  };
+};

apps/geo-device-service/src/routes/context.ts

@@ -0,0 +1,54 @@
+import { Router, type Request, type Response } from 'express';
+import { buildContext } from '../lib/context.js';
+
+const router = Router();
+
+interface ClientBody {
+  geo?: {
+    latitude?: number;
+    longitude?: number;
+    country?: string;
+    countryCode?: string;
+    region?: string;
+    city?: string;
+    timezone?: string;
+  };
+  client?: {
+    screenWidth?: number;
+    screenHeight?: number;
+    viewportWidth?: number;
+    viewportHeight?: number;
+    devicePixelRatio?: number;
+    timezone?: string;
+    language?: string;
+    languages?: string[];
+    platform?: string;
+    hardwareConcurrency?: number;
+    deviceMemory?: number;
+    cookieEnabled?: boolean;
+    doNotTrack?: string | null;
+  };
+}
+
+router.get('/context', (req: Request, res: Response) => {
+  try {
+    const context = buildContext(req);
+    res.json(context);
+  } catch (err) {
+    console.error('Error building context:', err);
+    res.status(500).json({ error: 'Failed to build context' });
+  }
+});
+
+router.post('/context', (req: Request<object, object, ClientBody>, res: Response) => {
+  try {
+    const clientData = req.body;
+    const context = buildContext(req, clientData);
+    res.json(context);
+  } catch (err) {
+    console.error('Error building context:', err);
+    res.status(500).json({ error: 'Failed to build context' });
+  }
+});
+
+export default router;

apps/geo-device-service/src/types.ts

@@ -0,0 +1,56 @@
+export interface GeoLocation {
+  latitude: number;
+  longitude: number;
+  country: string;
+  countryCode: string;
+  region: string;
+  city: string;
+  timezone: string;
+  source: 'ip' | 'client' | 'unknown';
+}
+
+export interface DeviceInfo {
+  type: 'desktop' | 'mobile' | 'tablet' | 'wearable' | 'smarttv' | 'unknown';
+  vendor?: string;
+  model?: string;
+}
+
+export interface BrowserInfo {
+  name: string;
+  version: string;
+  full: string;
+}
+
+export interface OSInfo {
+  name: string;
+  version: string;
+  full: string;
+}
+
+export interface ClientContext {
+  screenWidth?: number;
+  screenHeight?: number;
+  viewportWidth?: number;
+  viewportHeight?: number;
+  devicePixelRatio?: number;
+  timezone?: string;
+  language?: string;
+  languages?: string[];
+  platform?: string;
+  hardwareConcurrency?: number;
+  deviceMemory?: number;
+  cookieEnabled?: boolean;
+  doNotTrack?: string | null;
+}
+
+export interface GeoDeviceContext {
+  geo: GeoLocation | null;
+  device: DeviceInfo;
+  browser: BrowserInfo;
+  os: OSInfo;
+  client: ClientContext;
+  ip?: string;
+  userAgent: string;
+  acceptLanguage?: string;
+  requestedAt: string;
+}

apps/geo-device-service/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src/**/*"]
+}