Diseño de Sistemas: Acortador de URLs

// Diseño del API
interface URLShortenerAPI {
  // Crear una URL corta
  // POST /api/v1/shorten
  createShortURL(request: {
    longUrl: string;
    customAlias?: string;
    expiresAt?: Date;
  }): Promise<{
    shortUrl: string;
    longUrl: string;
    expiresAt: Date | null;
    createdAt: Date;
  }>;

  // Redirección (manejada a nivel HTTP)
  // GET /:shortCode -> redirección 301/302 a longUrl

  // Obtener analíticas
  // GET /api/v1/analytics/:shortCode
  getAnalytics(shortCode: string): Promise<{
    totalClicks: number;
    clicksByDay: Array<{ date: string; count: number }>;
    topReferrers: Array<{ referrer: string; count: number }>;
    topCountries: Array<{ country: string; count: number }>;
  }>;
}

// Esquema de base de datos
interface URLMapping {
  id: string;            // Clave primaria (auto-incremento o UUID)
  shortCode: string;     // Único, indexado - el código de URL corta (ej., "aB3x7K")
  longUrl: string;       // La URL original
  userId?: string;       // Opcional: quién la creó
  createdAt: Date;
  expiresAt?: Date;
  clickCount: number;    // Desnormalizado para acceso rápido
}

// Eventos de analíticas (tabla separada o cola de mensajes)
interface ClickEvent {
  id: string;
  shortCode: string;
  timestamp: Date;
  ipAddress: string;
  userAgent: string;
  referrer?: string;
  country?: string;
  device?: string;
}

// Esquema SQL
// CREATE TABLE url_mappings (
//   id BIGSERIAL PRIMARY KEY,
//   short_code VARCHAR(10) UNIQUE NOT NULL,
//   long_url TEXT NOT NULL,
//   user_id VARCHAR(36),
//   created_at TIMESTAMP DEFAULT NOW(),
//   expires_at TIMESTAMP,
//   click_count BIGINT DEFAULT 0
// );
// CREATE INDEX idx_short_code ON url_mappings(short_code);
// CREATE INDEX idx_expires_at ON url_mappings(expires_at) WHERE expires_at IS NOT NULL;

const BASE62_CHARS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";

function encodeBase62(num: number): string {
  if (num === 0) return BASE62_CHARS[0];

  let result = "";
  while (num > 0) {
    result = BASE62_CHARS[num % 62] + result;
    num = Math.floor(num / 62);
  }

  return result;
}

function decodeBase62(str: string): number {
  let result = 0;
  for (const char of str) {
    result = result * 62 + BASE62_CHARS.indexOf(char);
  }
  return result;
}

// Ejemplo: ID 1000000 -> base62 "4C92" (4 caracteres)
// Ejemplo: ID 3500000000000 -> base62 "Zzzzzz" (7 caracteres)

import { createHash } from "crypto";

function generateShortCode(longUrl: string, attempt = 0): string {
  const input = attempt === 0 ? longUrl : `${longUrl}${attempt}`;
  const hash = createHash("md5").update(input).digest("base64url");
  return hash.substring(0, 7); // Tomar los primeros 7 caracteres
}

async function createShortURL(longUrl: string, db: Database): Promise<string> {
  for (let attempt = 0; attempt < 5; attempt++) {
    const shortCode = generateShortCode(longUrl, attempt);

    // Verificar colisión
    const existing = await db.findByShortCode(shortCode);
    if (!existing) {
      await db.insert({ shortCode, longUrl });
      return shortCode;
    }

    // Si la misma URL ya fue acortada, retornar la existente
    if (existing.longUrl === longUrl) {
      return existing.shortCode;
    }

    // Colisión con URL diferente, intentar de nuevo
  }

  throw new Error("No se pudo generar un código corto único");
}

class URLRedirectService {
  private cache: RedisClient;
  private db: Database;

  async redirect(shortCode: string): Promise<string | null> {
    // Capa 1: Verificar caché Redis
    const cached = await this.cache.get(`url:${shortCode}`);
    if (cached) {
      this.trackClickAsync(shortCode); // Fire and forget
      return cached;
    }

    // Capa 2: Verificar base de datos
    const mapping = await this.db.findByShortCode(shortCode);
    if (!mapping) return null;

    // Verificar expiración
    if (mapping.expiresAt && mapping.expiresAt < new Date()) {
      return null;
    }

    // Popular caché para futuras solicitudes (TTL 24 horas)
    await this.cache.setex(`url:${shortCode}`, 86400, mapping.longUrl);

    this.trackClickAsync(shortCode); // Fire and forget
    return mapping.longUrl;
  }

  // Decisión de redirección 301 vs 302
  // 301 (Permanente): El navegador lo cachea, menos solicitudes a nuestro servidor
  //   - Pro: Reduce carga del servidor
  //   - Contra: Pierde analíticas (navegador va directo)
  // 302 (Temporal): El navegador siempre consulta nuestro servidor primero
  //   - Pro: Analíticas precisas
  //   - Contra: Más carga del servidor
  // Recomendación: Usar 302 si las analíticas importan, 301 para máximo rendimiento

  private trackClickAsync(shortCode: string): void {
    // Enviar a cola de mensajes para procesamiento asíncrono
    messageQueue.publish("clicks", {
      shortCode,
      timestamp: Date.now(),
      // ... otros metadatos
    });
  }
}

// Pipeline de analíticas
class AnalyticsProcessor {
  async processClickEvent(event: ClickEvent): Promise<void> {
    // Parsear user agent para info del dispositivo
    const deviceInfo = parseUserAgent(event.userAgent);

    // Geo-localizar desde IP
    const location = await geolocate(event.ipAddress);

    // Almacenar en base de datos de analíticas (optimizada para series de tiempo)
    await this.analyticsDB.insert({
      shortCode: event.shortCode,
      timestamp: event.timestamp,
      country: location.country,
      city: location.city,
      device: deviceInfo.device,
      browser: deviceInfo.browser,
      os: deviceInfo.os,
      referrer: event.referrer,
    });

    // Incrementar contadores (desnormalizados para lecturas rápidas)
    await this.cache.incr(`clicks:${event.shortCode}`);
    await this.cache.incr(`clicks:${event.shortCode}:${todayKey()}`);
  }
}