clean up ip-geo

Author: izadoesdev

apps/basket/src/index.ts

@@ -15,7 +15,7 @@ const app = new Elysia()
       )
     );
   })
-  .onBeforeHandle(async ({ request, set }) => {
+  .onBeforeHandle(({ request, set }) => {
     // const { isBot } = await checkBotId();
     // if (isBot) {
     //   return new Response(null, { status: 403 });

apps/basket/src/routes/stripe.ts

@@ -1,6 +1,7 @@
 import { clickHouse, db, eq, userStripeConfig } from '@databuddy/db';
 import { Elysia } from 'elysia';
 import Stripe from 'stripe';
+import { logger } from '../lib/logger';
 
 /**
  * STRIPE CHECKOUT SETUP GUIDE
@@ -102,10 +103,9 @@ async function getStripeConfigByToken(
       isLiveMode: config.isLiveMode,
     };
   } catch (error) {
-    console.error(
-      `Error fetching Stripe config for token ${webhookToken}:`,
-      error
-    );
+    logger.error(`Error fetching Stripe config for token ${webhookToken}`, {
+      error: error instanceof Error ? error.message : 'Unknown error',
+    });
     return null;
   }
 }
@@ -145,23 +145,32 @@ async function handleWebhook(request: Request, set: any, config: StripeConfig) {
       return { error: 'Live/test mode mismatch' };
     }
 
-    console.log(`📦 Stripe webhook received for user ${config.userId}:`, {
+    logger.info(`📦 Stripe webhook received for user ${config.userId}:`, {
       type: event.type,
       id: event.id,
       livemode: event.livemode,
     });
 
     try {
       await processWebhookEvent(event, config);
-      console.log(`✅ Successfully processed ${event.type}`);
+      logger.info(`✅ Successfully processed ${event.type}`);
     } catch (processingError) {
-      console.error('❌ Error processing webhook event:', processingError);
+      logger.error('❌ Error processing webhook event:', {
+        error:
+          processingError instanceof Error
+            ? processingError.message
+            : 'Unknown error',
+      });
+      set.status = 500;
+      return { error: 'Error processing webhook event' };
     }
 
     set.status = 200;
     return { received: true, eventType: event.type };
   } catch (err) {
-    console.error('⚠️ Webhook signature verification failed:', err);
+    logger.error('⚠️ Webhook signature verification failed:', {
+      error: err instanceof Error ? err.message : 'Unknown error',
+    });
     logSecurityEvent(
       'signature_verification_failed',
       config.webhookToken,
@@ -203,7 +212,7 @@ async function processWebhookEvent(event: Stripe.Event, config: StripeConfig) {
   if (handler) {
     await handler(event.data.object as any);
   } else {
-    console.log(`🔄 Unhandled event type: ${event.type}`);
+    logger.info(`🔄 Unhandled event type: ${event.type}`);
   }
 }
 
@@ -274,7 +283,7 @@ async function insertPaymentIntent(
     session_id: sessionId,
   });
 
-  console.log(`✅ PaymentIntent ${pi.id} processed for client ${clientId}`);
+  logger.info(`✅ PaymentIntent ${pi.id} processed for client ${clientId}`);
 }
 
 async function insertCharge(charge: Stripe.Charge, config: StripeConfig) {
@@ -309,7 +318,7 @@ async function insertCharge(charge: Stripe.Charge, config: StripeConfig) {
     session_id: sessionId,
   });
 
-  console.log(`✅ Charge ${charge.id} processed for client ${clientId}`);
+  logger.info(`✅ Charge ${charge.id} processed for client ${clientId}`);
 }
 
 async function insertRefund(refund: Stripe.Refund, config: StripeConfig) {
@@ -336,7 +345,7 @@ async function insertRefund(refund: Stripe.Refund, config: StripeConfig) {
     session_id: sessionId,
   });
 
-  console.log(`✅ Refund ${refund.id} processed for client ${clientId}`);
+  logger.info(`✅ Refund ${refund.id} processed for client ${clientId}`);
 }
 
 function logSecurityEvent(
@@ -353,12 +362,9 @@ function logSecurityEvent(
   };
 
   if (IS_PRODUCTION) {
-    console.warn(`🚨 Security Event: ${eventType}`, logData);
+    logger.warn(`🚨 Security Event: ${eventType}`, logData);
   } else {
-    console.log(`🔍 Security Event (disabled): ${eventType}`, {
-      webhookToken,
-      ip,
-    });
+    logger.info(`🔍 Security Event (disabled): ${eventType}`, logData);
   }
 }
 
@@ -379,7 +385,9 @@ function logSecurityEvent(
 //             })
 //             .where(eq(userStripeConfig.webhookToken, webhookToken))
 //     } catch (error) {
-//         console.error('Error updating webhook success:', error)
+//         logger.error('Error updating webhook success:', {
+//             error: error instanceof Error ? error.message : 'Unknown error',
+//         });
 //     }
 // }
 
@@ -398,7 +406,9 @@ function logSecurityEvent(
 //             })
 //             .where(eq(userStripeConfig.webhookToken, webhookToken))
 //     } catch (error) {
-//         console.error('Error updating webhook failure:', error)
+//         logger.error('Error updating webhook failure:', {
+//             error: error instanceof Error ? error.message : 'Unknown error',
+//         });
 //     }
 // }
 

apps/basket/src/utils/event-schema.ts

@@ -6,7 +6,9 @@ const resolutionSchema = z
   .regex(resolutionRegex, "Must be in the format 'WIDTHxHEIGHT'")
   .refine((val) => {
     const match = val.match(resolutionRegex);
-    if (!match) return false;
+    if (!match) {
+      return false;
+    }
     const width = Number(match[1]);
     const height = Number(match[2]);
     return width >= 240 && width <= 10_000 && height >= 240 && height <= 10_000;

apps/basket/src/utils/ip-geo.ts

@@ -5,12 +5,12 @@ import {
   BadMethodCallError,
   Reader,
 } from '@maxmind/geoip2-node';
+import { logger } from '../lib/logger';
 
 interface GeoIPReader extends Reader {
   city(ip: string): City;
 }
 
-// Database configuration
 const CDN_URL = 'https://cdn.databuddy.cc/GeoLite2-City.mmdb';
 
 let reader: GeoIPReader | null = null;
@@ -30,22 +30,20 @@ async function loadDatabaseFromCdn(): Promise<Buffer> {
     const arrayBuffer = await response.arrayBuffer();
     const dbBuffer = Buffer.from(arrayBuffer);
 
-    // Validate that we got a reasonable file size (should be ~50-100MB)
     if (dbBuffer.length < 1_000_000) {
-      // Less than 1MB
       throw new Error(
         `Database file seems too small: ${dbBuffer.length} bytes`
       );
     }
 
     return dbBuffer;
   } catch (error) {
-    console.error('Failed to load database from CDN:', error);
+    logger.error('Failed to load database from CDN:', { error });
     throw error;
   }
 }
 
-async function loadDatabase() {
+function loadDatabase() {
   if (loadError) {
     throw loadError;
   }
@@ -63,12 +61,11 @@ async function loadDatabase() {
     try {
       const dbBuffer = await loadDatabaseFromCdn();
 
-      // Add a small delay to prevent overwhelming the system
       await new Promise((resolve) => setTimeout(resolve, 100));
 
       reader = Reader.openBuffer(dbBuffer) as GeoIPReader;
     } catch (error) {
-      console.error('Failed to load GeoIP database:', error);
+      logger.error('Failed to load GeoIP database:', { error });
       loadError = error as Error;
       reader = null;
     } finally {
@@ -79,21 +76,25 @@ async function loadDatabase() {
   return loadPromise;
 }
 
-// Don't initialize on module load - wait for first use
 const ignore = ['127.0.0.1', '::1'];
 
-// Helper function to validate IP address format
+const ipv4Regex =
+  /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
+
+const ipv6Regex = /^(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$/;
+
 function isValidIp(ip: string): boolean {
-  if (!ip) return false;
+  if (!ip) {
+    return false;
+  }
 
-  // Check for IPv4 format
-  const ipv4Regex =
-    /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
-  if (ipv4Regex.test(ip)) return true;
+  if (ipv4Regex.test(ip)) {
+    return true;
+  }
 
-  // Check for IPv6 format (basic check)
-  const ipv6Regex = /^(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$/;
-  if (ipv6Regex.test(ip)) return true;
+  if (ipv6Regex.test(ip)) {
+    return true;
+  }
 
   return false;
 }
@@ -103,12 +104,11 @@ export async function getGeoLocation(ip: string) {
     return { country: undefined, region: undefined, city: undefined };
   }
 
-  // Lazy load database on first use
   if (!(reader || isLoading || loadError)) {
     try {
       await loadDatabase();
     } catch (error) {
-      console.error('Failed to load database for IP lookup:', error);
+      logger.error('Failed to load database for IP lookup:', { error });
       return { country: undefined, region: undefined, city: undefined };
     }
   }
@@ -137,41 +137,48 @@ export async function getGeoLocation(ip: string) {
 
     // Handle BadMethodCallError (wrong database type)
     if (error instanceof BadMethodCallError) {
-      console.error(
+      logger.error(
         'Database type mismatch - using city() method with ipinfo database'
       );
       return { country: undefined, region: undefined, city: undefined };
     }
 
-    // Handle other errors
-    console.error('Error looking up IP:', ip, error);
+    logger.error('Error looking up IP:', { ip, error });
     return { country: undefined, region: undefined, city: undefined };
   }
 }
 
 export function getClientIp(req: Request): string | undefined {
   const cfIp = req.headers.get('cf-connecting-ip');
-  if (cfIp) return cfIp;
+  if (cfIp) {
+    return cfIp;
+  }
 
   const forwardedFor = req.headers.get('x-forwarded-for');
   if (forwardedFor) {
     const firstIp = forwardedFor.split(',')[0]?.trim();
-    if (firstIp) return firstIp;
+    if (firstIp) {
+      return firstIp;
+    }
   }
 
   const realIp = req.headers.get('x-real-ip');
-  if (realIp) return realIp;
+  if (realIp) {
+    return realIp;
+  }
 
   return;
 }
 
-export async function parseIp(req: Request) {
+export function parseIp(req: Request) {
   const ip = getClientIp(req);
   return getGeoLocation(ip || '');
 }
 
 export function anonymizeIp(ip: string): string {
-  if (!ip) return '';
+  if (!ip) {
+    return '';
+  }
 
   const salt = process.env.IP_HASH_SALT || 'databuddy-ip-salt';
   const hash = createHash('sha256');
@@ -191,14 +198,20 @@ export async function getGeo(ip: string) {
 
 export function extractIpFromRequest(request: Request): string {
   const cfIp = request.headers.get('cf-connecting-ip');
-  if (cfIp) return cfIp.trim();
+  if (cfIp) {
+    return cfIp.trim();
+  }
 
   const forwardedFor = request.headers.get('x-forwarded-for');
   const firstIp = forwardedFor?.split(',')[0]?.trim();
-  if (firstIp) return firstIp;
+  if (firstIp) {
+    return firstIp;
+  }
 
   const realIp = request.headers.get('x-real-ip');
-  if (realIp) return realIp.trim();
+  if (realIp) {
+    return realIp.trim();
+  }
 
   return '';
 }

apps/basket/src/utils/user-agent.ts

@@ -5,7 +5,7 @@
  * and platform identification.
  */
 
-import { bots } from '@databuddy/shared';
+import { bots, logger } from '@databuddy/shared';
 import { UAParser } from 'ua-parser-js';
 
 export interface UserAgentInfo {
@@ -57,7 +57,13 @@ export function parseUserAgent(userAgent: string): {
       deviceModel: result.device.model || undefined,
     };
   } catch (error) {
-    // If parsing fails, return undefined values
+    logger.error(
+      'User Agent Parse Error',
+      `Failed to parse user agent: ${userAgent}`,
+      {
+        error: error instanceof Error ? error.message : 'Unknown error',
+      }
+    );
     return {
       browserName: undefined,
       browserVersion: undefined,