URL短縮ツール完全ガイド2025｜効果的なリンク管理とマーケティング分析

なぜURL短縮が重要なのか？

デジタルマーケティングにおいて、URL短縮は単なる文字数削減以上の価値を提供します。分析、ブランディング、ユーザー体験の向上など、ビジネス成功の鍵となる機能を実現します。

URL短縮の必要性

統計データ（2025年）

SNS投稿のクリック率が39%向上（短縮URL使用時）
毎日50億の短縮URLが生成
マーケティングキャンペーンの**67%**がURL短縮を活用
モバイルユーザーの**85%**が長いURLを避ける傾向

短縮URLの利点

文字数制限対応: Twitter、SMS、印刷物
クリック分析: 詳細なユーザー行動データ
ブランディング: カスタムドメインで信頼性向上
A/Bテスト: 複数バリエーションの効果測定
セキュリティ: 悪意あるリンクの検出とブロック

i4u URL短縮ツールは、これらすべての機能を無料で提供します。

URL短縮の仕組み

技術的な実装

// URL短縮の基本アルゴリズム
class URLShortener {
  constructor() {
    this.database = new Map();
    this.counter = 1000000; // 開始ID
  }

  // Base62エンコーディング
  toBase62(num) {
    const chars = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
    let result = '';

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

    return result || '0';
  }

  // URL短縮
  shorten(longUrl) {
    // 既存チェック
    for (let [short, data] of this.database) {
      if (data.longUrl === longUrl) {
        return `https://short.link/${short}`;
      }
    }

    // 新規作成
    const shortCode = this.toBase62(this.counter++);
    this.database.set(shortCode, {
      longUrl,
      shortCode,
      created: new Date(),
      clicks: 0,
      lastAccessed: null
    });

    return `https://short.link/${shortCode}`;
  }

  // リダイレクト処理
  redirect(shortCode) {
    const data = this.database.get(shortCode);

    if (!data) {
      return null;
    }

    // 統計更新
    data.clicks++;
    data.lastAccessed = new Date();

    return data.longUrl;
  }
}

データベース設計

-- URLテーブル
CREATE TABLE urls (
  id BIGINT PRIMARY KEY AUTO_INCREMENT,
  short_code VARCHAR(10) UNIQUE NOT NULL,
  long_url TEXT NOT NULL,
  custom_alias VARCHAR(50),
  user_id BIGINT,
  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
  expires_at TIMESTAMP NULL,
  is_active BOOLEAN DEFAULT true,
  INDEX idx_short_code (short_code),
  INDEX idx_user_id (user_id)
);

-- クリック統計テーブル
CREATE TABLE clicks (
  id BIGINT PRIMARY KEY AUTO_INCREMENT,
  url_id BIGINT NOT NULL,
  clicked_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
  ip_address VARCHAR(45),
  user_agent TEXT,
  referer TEXT,
  country VARCHAR(2),
  city VARCHAR(100),
  device_type ENUM('desktop', 'mobile', 'tablet'),
  os VARCHAR(50),
  browser VARCHAR(50),
  FOREIGN KEY (url_id) REFERENCES urls(id),
  INDEX idx_url_id (url_id),
  INDEX idx_clicked_at (clicked_at)
);

-- カスタムドメインテーブル
CREATE TABLE custom_domains (
  id INT PRIMARY KEY AUTO_INCREMENT,
  user_id BIGINT NOT NULL,
  domain VARCHAR(255) UNIQUE NOT NULL,
  ssl_enabled BOOLEAN DEFAULT false,
  verified BOOLEAN DEFAULT false,
  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
  FOREIGN KEY (user_id) REFERENCES users(id)
);

実践的な活用事例

1. SNSマーケティング

Twitter/X最適化

// Twitter用URL最適化
class TwitterURLOptimizer {
  constructor() {
    this.maxTweetLength = 280;
    this.urlLength = 23; // TwitterのURL文字数カウント
  }

  optimizeTweet(text, urls) {
    let optimizedTweet = text;
    let savedChars = 0;

    urls.forEach(url => {
      const shortUrl = this.shortenURL(url);
      optimizedTweet = optimizedTweet.replace(url, shortUrl);
      savedChars += url.length - this.urlLength;
    });

    return {
      tweet: optimizedTweet,
      charactersRemaining: this.maxTweetLength - optimizedTweet.length,
      savedCharacters: savedChars,
      canAddHashtags: optimizedTweet.length < 260
    };
  }

  addUTMParameters(url, campaign) {
    const utm = {
      utm_source: 'twitter',
      utm_medium: 'social',
      utm_campaign: campaign,
      utm_content: `tweet_${Date.now()}`
    };

    const urlObj = new URL(url);
    Object.entries(utm).forEach(([key, value]) => {
      urlObj.searchParams.set(key, value);
    });

    return urlObj.toString();
  }
}

Instagram Bio リンク管理

# Instagram用リンクツリー実装
class LinkTreeManager:
    def __init__(self):
        self.links = []
        self.base_url = "https://link.bio/"

    def create_landing_page(self, username, links):
        """複数リンクを1つのランディングページに集約"""
        page_id = self.generate_page_id(username)

        landing_page = {
            'id': page_id,
            'username': username,
            'links': [],
            'theme': 'default',
            'analytics': {
                'total_views': 0,
                'link_clicks': {}
            }
        }

        for link in links:
            short_link = self.shorten_for_tracking(link['url'])
            landing_page['links'].append({
                'title': link['title'],
                'description': link.get('description', ''),
                'url': short_link,
                'icon': link.get('icon', '🔗'),
                'clicks': 0
            })

        return f"{self.base_url}{page_id}"

    def track_click(self, page_id, link_index):
        """リンククリックを追跡"""
        timestamp = datetime.now()
        analytics_data = {
            'page_id': page_id,
            'link_index': link_index,
            'timestamp': timestamp,
            'user_agent': request.headers.get('User-Agent'),
            'ip': request.remote_addr
        }

        self.save_analytics(analytics_data)

2. メールマーケティング

メール配信最適化

// メールキャンペーン用URL管理
class EmailCampaignURLManager {
  constructor(campaignId) {
    this.campaignId = campaignId;
    this.links = new Map();
  }

  processEmailContent(htmlContent) {
    const urlRegex = /<a[^>]+href=["']([^"']+)["'][^>]*>/gi;
    let processedContent = htmlContent;
    let match;

    while ((match = urlRegex.exec(htmlContent)) !== null) {
      const originalUrl = match[1];
      const trackableUrl = this.createTrackableUrl(originalUrl);
      processedContent = processedContent.replace(
        originalUrl,
        trackableUrl
      );
    }

    return processedContent;
  }

  createTrackableUrl(originalUrl) {
    // ユニークIDの生成
    const linkId = this.generateLinkId();

    // トラッキングパラメータ追加
    const trackingUrl = new URL(originalUrl);
    trackingUrl.searchParams.set('utm_source', 'email');
    trackingUrl.searchParams.set('utm_medium', 'email');
    trackingUrl.searchParams.set('utm_campaign', this.campaignId);
    trackingUrl.searchParams.set('link_id', linkId);

    // 短縮URL生成
    const shortUrl = this.shorten(trackingUrl.toString());

    // マッピング保存
    this.links.set(linkId, {
      original: originalUrl,
      short: shortUrl,
      clicks: 0,
      uniqueClicks: new Set(),
      conversions: 0
    });

    return shortUrl;
  }

  generateReport() {
    const report = {
      campaignId: this.campaignId,
      totalLinks: this.links.size,
      totalClicks: 0,
      uniqueClicks: 0,
      clickThroughRate: 0,
      topPerformingLinks: [],
      deviceBreakdown: {},
      timeAnalysis: {}
    };

    // 統計集計
    this.links.forEach((data, linkId) => {
      report.totalClicks += data.clicks;
      report.uniqueClicks += data.uniqueClicks.size;

      report.topPerformingLinks.push({
        url: data.original,
        clicks: data.clicks,
        conversionRate: (data.conversions / data.clicks) * 100
      });
    });

    // CTR計算
    report.clickThroughRate = (report.uniqueClicks / this.emailsSent) * 100;

    // 上位リンクのソート
    report.topPerformingLinks.sort((a, b) => b.clicks - a.clicks);

    return report;
  }
}

3. QRコード統合

QRコード + 短縮URL

import qrcode
import io
from PIL import Image

class QRShortURLGenerator:
    def __init__(self):
        self.shortener = URLShortener()

    def generate_qr_with_short_url(self, long_url, options={}):
        """短縮URLのQRコード生成"""
        # URL短縮
        short_url = self.shortener.shorten(long_url)

        # QRコード生成
        qr = qrcode.QRCode(
            version=options.get('version', 1),
            error_correction=qrcode.constants.ERROR_CORRECT_M,
            box_size=options.get('box_size', 10),
            border=options.get('border', 4),
        )

        qr.add_data(short_url)
        qr.make(fit=True)

        # 画像生成
        img = qr.make_image(
            fill_color=options.get('fill_color', 'black'),
            back_color=options.get('back_color', 'white')
        )

        # ロゴ埋め込み（オプション）
        if options.get('logo_path'):
            img = self.embed_logo(img, options['logo_path'])

        return {
            'qr_image': img,
            'short_url': short_url,
            'original_url': long_url,
            'qr_data_capacity': len(short_url),
            'savings': len(long_url) - len(short_url)
        }

    def embed_logo(self, qr_img, logo_path):
        """QRコード中央にロゴ埋め込み"""
        logo = Image.open(logo_path)

        # ロゴサイズ調整（QRコードの1/5）
        qr_width, qr_height = qr_img.size
        logo_size = min(qr_width, qr_height) // 5
        logo = logo.resize((logo_size, logo_size), Image.Resampling.LANCZOS)

        # 中央配置
        pos = (
            (qr_width - logo_size) // 2,
            (qr_height - logo_size) // 2
        )

        qr_img.paste(logo, pos, logo if logo.mode == 'RGBA' else None)
        return qr_img

4. アフィリエイトマーケティング

アフィリエイトリンク管理

// アフィリエイトリンククローキング
class AffiliateLinkManager {
  constructor() {
    this.affiliatePrograms = new Map();
    this.conversionTracking = new Map();
  }

  registerAffiliateProgram(programName, config) {
    this.affiliatePrograms.set(programName, {
      baseUrl: config.baseUrl,
      affiliateId: config.affiliateId,
      subIdTracking: config.subIdTracking || false,
      cookieDuration: config.cookieDuration || 30
    });
  }

  createAffiliateLink(productUrl, programName, campaign) {
    const program = this.affiliatePrograms.get(programName);

    if (!program) {
      throw new Error(`Unknown affiliate program: ${programName}`);
    }

    // アフィリエイトパラメータ追加
    const affiliateUrl = new URL(productUrl);
    affiliateUrl.searchParams.set('aid', program.affiliateId);

    if (program.subIdTracking) {
      const subId = this.generateSubId(campaign);
      affiliateUrl.searchParams.set('sub', subId);
    }

    // クローキング用短縮URL生成
    const cloakedUrl = this.createCloakedUrl({
      destination: affiliateUrl.toString(),
      program: programName,
      campaign: campaign,
      product: this.extractProductId(productUrl)
    });

    return {
      original: productUrl,
      affiliate: affiliateUrl.toString(),
      cloaked: cloakedUrl,
      tracking: {
        program: programName,
        campaign: campaign,
        created: new Date()
      }
    };
  }

  trackConversion(shortCode, conversionData) {
    const linkData = this.getLinkData(shortCode);

    if (!linkData) return false;

    const conversion = {
      linkId: linkData.id,
      program: linkData.program,
      amount: conversionData.amount,
      currency: conversionData.currency,
      timestamp: new Date(),
      status: 'pending'
    };

    this.conversionTracking.set(
      `${linkData.id}_${Date.now()}`,
      conversion
    );

    // コミッション計算
    const commission = this.calculateCommission(
      linkData.program,
      conversionData.amount
    );

    return {
      success: true,
      conversion,
      estimatedCommission: commission
    };
  }

  generatePerformanceReport(dateRange) {
    const report = {
      period: dateRange,
      programs: {},
      totalClicks: 0,
      totalConversions: 0,
      totalRevenue: 0,
      totalCommission: 0,
      topPerformingLinks: [],
      conversionRate: 0
    };

    // プログラム別集計
    this.affiliatePrograms.forEach((program, name) => {
      report.programs[name] = {
        clicks: 0,
        conversions: 0,
        revenue: 0,
        commission: 0,
        conversionRate: 0,
        averageOrderValue: 0
      };
    });

    // データ集計ロジック
    // ... (実装詳細)

    return report;
  }
}

5. A/Bテスト実装

マルチバリアントテスト

import random
from datetime import datetime, timedelta

class ABTestingURLManager:
    def __init__(self):
        self.tests = {}
        self.results = {}

    def create_ab_test(self, test_name, variants, traffic_split=None):
        """A/Bテストの作成"""
        if not traffic_split:
            # 均等配分
            traffic_split = [100 / len(variants)] * len(variants)

        test_id = self.generate_test_id()

        self.tests[test_id] = {
            'name': test_name,
            'variants': [],
            'traffic_split': traffic_split,
            'start_date': datetime.now(),
            'end_date': None,
            'status': 'active',
            'winner': None
        }

        # 各バリアント用の短縮URL生成
        for i, variant in enumerate(variants):
            short_url = self.create_variant_url(test_id, i)
            self.tests[test_id]['variants'].append({
                'index': i,
                'url': variant['url'],
                'short_url': short_url,
                'name': variant.get('name', f'Variant {i+1}'),
                'description': variant.get('description', ''),
                'impressions': 0,
                'clicks': 0,
                'conversions': 0
            })

        return test_id

    def route_traffic(self, test_id):
        """トラフィックをバリアントに振り分け"""
        test = self.tests.get(test_id)

        if not test or test['status'] != 'active':
            return None

        # 重み付きランダム選択
        rand = random.random() * 100
        cumulative = 0

        for i, weight in enumerate(test['traffic_split']):
            cumulative += weight
            if rand <= cumulative:
                variant = test['variants'][i]

                # インプレッション記録
                variant['impressions'] += 1

                return variant['url']

        return test['variants'][-1]['url']

    def record_click(self, test_id, variant_index):
        """クリックを記録"""
        test = self.tests.get(test_id)
        if test and variant_index < len(test['variants']):
            test['variants'][variant_index]['clicks'] += 1

    def record_conversion(self, test_id, variant_index, value=1):
        """コンバージョンを記録"""
        test = self.tests.get(test_id)
        if test and variant_index < len(test['variants']):
            test['variants'][variant_index]['conversions'] += value

    def calculate_statistics(self, test_id):
        """統計的有意性を計算"""
        test = self.tests.get(test_id)
        if not test:
            return None

        results = {
            'test_id': test_id,
            'test_name': test['name'],
            'duration': (datetime.now() - test['start_date']).days,
            'variants': []
        }

        for variant in test['variants']:
            ctr = (variant['clicks'] / variant['impressions'] * 100) if variant['impressions'] > 0 else 0
            cvr = (variant['conversions'] / variant['clicks'] * 100) if variant['clicks'] > 0 else 0

            results['variants'].append({
                'name': variant['name'],
                'impressions': variant['impressions'],
                'clicks': variant['clicks'],
                'conversions': variant['conversions'],
                'click_through_rate': round(ctr, 2),
                'conversion_rate': round(cvr, 2)
            })

        # 勝者判定（簡易版）
        if results['variants']:
            best_variant = max(results['variants'], key=lambda x: x['conversion_rate'])
            results['current_winner'] = best_variant['name']

            # 統計的有意性（簡易計算）
            results['confidence_level'] = self.calculate_confidence(test['variants'])

        return results

    def calculate_confidence(self, variants):
        """信頼度を計算（簡易版）"""
        # 実際の実装では、適切な統計的検定を使用
        if len(variants) < 2:
            return 0

        impressions = [v['impressions'] for v in variants]
        conversions = [v['conversions'] for v in variants]

        # サンプルサイズチェック
        min_sample_size = 100
        if min(impressions) < min_sample_size:
            return 0

        # 簡易的な信頼度計算
        # 実際はカイ二乗検定やz検定を使用
        return min(95, max(impressions) / min_sample_size)

分析とレポート機能

リアルタイム分析ダッシュボード

// リアルタイム分析システム
class RealTimeAnalytics {
  constructor() {
    this.activeVisitors = new Map();
    this.clickStream = [];
    this.geoData = new Map();
  }

  trackClick(shortCode, requestData) {
    const timestamp = new Date();
    const geoInfo = this.getGeoLocation(requestData.ip);

    const clickData = {
      shortCode,
      timestamp,
      ip: requestData.ip,
      userAgent: requestData.userAgent,
      referer: requestData.referer,
      country: geoInfo.country,
      city: geoInfo.city,
      coordinates: geoInfo.coordinates,
      device: this.detectDevice(requestData.userAgent),
      browser: this.detectBrowser(requestData.userAgent),
      os: this.detectOS(requestData.userAgent)
    };

    // リアルタイムストリームに追加
    this.clickStream.push(clickData);

    // アクティブビジター更新
    this.updateActiveVisitors(clickData);

    // 地理データ更新
    this.updateGeoData(geoInfo);

    // WebSocketで配信
    this.broadcastUpdate(clickData);

    return clickData;
  }

  generateDashboardData() {
    const now = new Date();
    const last24Hours = new Date(now - 24 * 60 * 60 * 1000);
    const lastHour = new Date(now - 60 * 60 * 1000);

    return {
      realtime: {
        activeVisitors: this.activeVisitors.size,
        clicksLastMinute: this.getClicksInTimeRange(now - 60000, now),
        clicksLastHour: this.getClicksInTimeRange(lastHour, now),
        topCountries: this.getTopCountries(5),
        topCities: this.getTopCities(10),
        deviceBreakdown: this.getDeviceBreakdown(),
        browserBreakdown: this.getBrowserBreakdown()
      },
      historical: {
        last24Hours: this.getHourlyBreakdown(24),
        last7Days: this.getDailyBreakdown(7),
        last30Days: this.getDailyBreakdown(30),
        topReferrers: this.getTopReferrers(10),
        topDestinations: this.getTopDestinations(10)
      },
      heatmap: this.generateClickHeatmap(),
      performance: {
        averageRedirectTime: this.calculateAverageRedirectTime(),
        uptimePercentage: this.calculateUptime(),
        errorRate: this.calculateErrorRate()
      }
    };
  }

  generateClickHeatmap() {
    const heatmap = {};

    // 曜日×時間のヒートマップデータ
    for (let day = 0; day < 7; day++) {
      heatmap[day] = {};
      for (let hour = 0; hour < 24; hour++) {
        heatmap[day][hour] = 0;
      }
    }

    this.clickStream.forEach(click => {
      const date = new Date(click.timestamp);
      const day = date.getDay();
      const hour = date.getHours();
      heatmap[day][hour]++;
    });

    return heatmap;
  }
}

セキュリティ対策

悪意あるリンクの検出

import re
import hashlib
from urllib.parse import urlparse

class URLSecurityScanner:
    def __init__(self):
        self.blacklist = set()
        self.whitelist = set()
        self.phishing_patterns = [
            r'[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}',  # IPアドレス
            r'bit\.ly.*bit\.ly',  # 多重リダイレクト
            r'[a-z0-9]+-[a-z0-9]+-[a-z0-9]+-[a-z0-9]+\.tk',  # 怪しいドメイン
        ]
        self.suspicious_tlds = ['.tk', '.ml', '.ga', '.cf']

    def scan_url(self, url):
        """URLのセキュリティスキャン"""
        scan_results = {
            'url': url,
            'status': 'safe',
            'threats': [],
            'risk_score': 0,
            'recommendations': []
        }

        # ブラックリストチェック
        if self.is_blacklisted(url):
            scan_results['status'] = 'dangerous'
            scan_results['threats'].append('Blacklisted URL')
            scan_results['risk_score'] += 100
            return scan_results

        # ホワイトリストチェック
        if self.is_whitelisted(url):
            return scan_results

        # URLパース
        parsed = urlparse(url)

        # HTTPSチェック
        if parsed.scheme != 'https':
            scan_results['threats'].append('Non-HTTPS URL')
            scan_results['risk_score'] += 20
            scan_results['recommendations'].append('Use HTTPS for secure connection')

        # 怪しいTLDチェック
        for tld in self.suspicious_tlds:
            if parsed.netloc.endswith(tld):
                scan_results['threats'].append(f'Suspicious TLD: {tld}')
                scan_results['risk_score'] += 30

        # パターンマッチング
        for pattern in self.phishing_patterns:
            if re.search(pattern, url):
                scan_results['threats'].append('Matches phishing pattern')
                scan_results['risk_score'] += 40

        # ホモグラフ攻撃チェック
        if self.check_homograph_attack(parsed.netloc):
            scan_results['threats'].append('Possible homograph attack')
            scan_results['risk_score'] += 50

        # リスクレベル判定
        if scan_results['risk_score'] >= 70:
            scan_results['status'] = 'dangerous'
        elif scan_results['risk_score'] >= 30:
            scan_results['status'] = 'suspicious'
        else:
            scan_results['status'] = 'safe'

        return scan_results

    def check_homograph_attack(self, domain):
        """ホモグラフ攻撃の検出"""
        # 似た文字の置換パターン
        homograph_chars = {
            'o': ['0', 'о'],  # ラテンのo、数字の0、キリル文字のо
            'e': ['е', 'ё'],  # キリル文字
            'a': ['а', '@'],  # キリル文字のа
            'i': ['1', 'l', 'і'],  # 数字の1、小文字のl、キリル文字
        }

        # 有名ドメインとの類似性チェック
        famous_domains = ['google', 'facebook', 'amazon', 'apple', 'microsoft']

        for famous in famous_domains:
            similarity = self.calculate_similarity(domain.lower(), famous)
            if similarity > 0.8 and domain.lower() != famous:
                return True

        return False

    def calculate_similarity(self, str1, str2):
        """文字列類似度計算（レーベンシュタイン距離）"""
        if len(str1) < len(str2):
            str1, str2 = str2, str1

        if len(str2) == 0:
            return 0.0

        previous_row = range(len(str2) + 1)
        for i, c1 in enumerate(str1):
            current_row = [i + 1]
            for j, c2 in enumerate(str2):
                insertions = previous_row[j + 1] + 1
                deletions = current_row[j] + 1
                substitutions = previous_row[j] + (c1 != c2)
                current_row.append(min(insertions, deletions, substitutions))
            previous_row = current_row

        distance = previous_row[-1]
        max_len = max(len(str1), len(str2))
        return 1 - (distance / max_len)

API実装

RESTful API設計

// Express.js API実装
const express = require('express');
const router = express.Router();

// URL短縮エンドポイント
router.post('/api/v1/shorten', async (req, res) => {
  try {
    const { url, customAlias, expiresIn, password } = req.body;

    // URL検証
    if (!isValidURL(url)) {
      return res.status(400).json({
        error: 'Invalid URL format'
      });
    }

    // セキュリティスキャン
    const securityScan = await scanURL(url);
    if (securityScan.status === 'dangerous') {
      return res.status(403).json({
        error: 'URL blocked for security reasons',
        details: securityScan.threats
      });
    }

    // カスタムエイリアスの重複チェック
    if (customAlias) {
      const exists = await checkAliasExists(customAlias);
      if (exists) {
        return res.status(409).json({
          error: 'Custom alias already in use'
        });
      }
    }

    // 短縮URL生成
    const shortUrl = await createShortURL({
      originalUrl: url,
      customAlias,
      expiresAt: expiresIn ? new Date(Date.now() + expiresIn) : null,
      password: password ? await hashPassword(password) : null,
      userId: req.user?.id
    });

    res.status(201).json({
      success: true,
      data: {
        shortUrl: `${BASE_URL}/${shortUrl.code}`,
        originalUrl: url,
        qrCode: `${BASE_URL}/api/v1/qr/${shortUrl.code}`,
        statistics: `${BASE_URL}/api/v1/stats/${shortUrl.code}`,
        expiresAt: shortUrl.expiresAt,
        created: shortUrl.createdAt
      }
    });

  } catch (error) {
    console.error('Shorten error:', error);
    res.status(500).json({
      error: 'Internal server error'
    });
  }
});

// 統計取得エンドポイント
router.get('/api/v1/stats/:code', async (req, res) => {
  try {
    const { code } = req.params;
    const { startDate, endDate, groupBy } = req.query;

    const stats = await getURLStatistics(code, {
      startDate: startDate ? new Date(startDate) : null,
      endDate: endDate ? new Date(endDate) : null,
      groupBy: groupBy || 'day'
    });

    if (!stats) {
      return res.status(404).json({
        error: 'Short URL not found'
      });
    }

    res.json({
      success: true,
      data: stats
    });

  } catch (error) {
    console.error('Stats error:', error);
    res.status(500).json({
      error: 'Internal server error'
    });
  }
});

// バルクURL短縮
router.post('/api/v1/bulk', async (req, res) => {
  try {
    const { urls } = req.body;

    if (!Array.isArray(urls) || urls.length === 0) {
      return res.status(400).json({
        error: 'Invalid request: urls must be a non-empty array'
      });
    }

    if (urls.length > 100) {
      return res.status(400).json({
        error: 'Maximum 100 URLs per request'
      });
    }

    const results = await Promise.all(
      urls.map(async (urlData) => {
        try {
          const shortUrl = await createShortURL({
            originalUrl: urlData.url,
            customAlias: urlData.alias,
            metadata: urlData.metadata
          });

          return {
            success: true,
            originalUrl: urlData.url,
            shortUrl: `${BASE_URL}/${shortUrl.code}`
          };
        } catch (error) {
          return {
            success: false,
            originalUrl: urlData.url,
            error: error.message
          };
        }
      })
    );

    res.json({
      success: true,
      data: results,
      summary: {
        total: urls.length,
        successful: results.filter(r => r.success).length,
        failed: results.filter(r => !r.success).length
      }
    });

  } catch (error) {
    console.error('Bulk shorten error:', error);
    res.status(500).json({
      error: 'Internal server error'
    });
  }
});

パフォーマンス最適化

キャッシング戦略

// Redis キャッシング実装
const Redis = require('ioredis');
const redis = new Redis();

class URLCache {
  constructor() {
    this.ttl = 3600; // 1時間
    this.namespace = 'url:';
  }

  async get(shortCode) {
    const key = `${this.namespace}${shortCode}`;
    const cached = await redis.get(key);

    if (cached) {
      // キャッシュヒット統計
      await redis.hincrby('stats:cache', 'hits', 1);
      return JSON.parse(cached);
    }

    // キャッシュミス統計
    await redis.hincrby('stats:cache', 'misses', 1);
    return null;
  }

  async set(shortCode, data) {
    const key = `${this.namespace}${shortCode}`;
    await redis.setex(
      key,
      this.ttl,
      JSON.stringify(data)
    );
  }

  async invalidate(shortCode) {
    const key = `${this.namespace}${shortCode}`;
    await redis.del(key);
  }

  async warmup(popularUrls) {
    // 人気URLを事前キャッシュ
    const pipeline = redis.pipeline();

    for (const url of popularUrls) {
      const key = `${this.namespace}${url.shortCode}`;
      pipeline.setex(
        key,
        this.ttl * 2, // 人気URLは長めにキャッシュ
        JSON.stringify(url)
      );
    }

    await pipeline.exec();
  }
}