@things-factory/weather 9.1.19 → 10.0.0-beta.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/weather",
-  "version": "9.1.19",
+  "version": "10.0.0-beta.1",
   "main": "dist-server/index.js",
   "browser": "dist-client/index.js",
   "things-factory": true,
@@ -29,17 +29,17 @@
   "dependencies": {
     "@hyperviz/weather": "^0.1.0",
     "@mapbox/mbtiles": "^0.12.1",
-    "@operato/graphql": "^9.0.0",
-    "@operato/shell": "^9.0.0",
-    "@things-factory/auth-base": "^9.1.19",
-    "@things-factory/cache-service": "^9.1.19",
-    "@things-factory/env": "^9.1.13",
-    "@things-factory/shell": "^9.1.19",
+    "@operato/graphql": "^10.0.0-beta.1",
+    "@operato/shell": "^10.0.0-beta.1",
+    "@things-factory/auth-base": "^10.0.0-beta.1",
+    "@things-factory/cache-service": "^10.0.0-beta.1",
+    "@things-factory/env": "^10.0.0-beta.1",
+    "@things-factory/shell": "^10.0.0-beta.1",
     "colormap": "^2.3.2",
     "ol": "^10.4.0"
   },
   "devDependencies": {
     "@types/colormap": "^2.3.4"
   },
-  "gitHead": "078438034dbe19915108e89ff24024f7044a85a9"
+  "gitHead": "90f40bf160fa25edf4560d7893cfd576cf474411"
 }

package/client/tsconfig.json

@@ -1,11 +0,0 @@
-{
-  "extends": "../../tsconfig-base.json",
-  "compilerOptions": {
-    "strict": true,
-    "declaration": true,
-    "module": "esnext",
-    "outDir": "../dist-client",
-    "baseUrl": "./"
-  },
-  "include": ["./**/*"]
-}

package/server/controllers/open-meteo-adapter.ts

@@ -1,96 +0,0 @@
-import { config } from '@things-factory/env'
-import { WeatherService, WeatherData, WeatherAround, Location } from './types.js'
-
-const baseUrl = 'https://api.open-meteo.com/v1/forecast'
-const apiKey = config.get('ApiKey')
-
-export async function getWeatherByLocation(location: Location): Promise<WeatherData> {
-  const url = `${baseUrl}?apiKey=${apiKey}&latitude=${location.latitude}&longitude=${location.longitude}&current=temperature_2m,windspeed_10m,cloudcover,relative_humidity_2m,shortwave_radiation&timezone=UTC`
-
-  const response = await fetch(url)
-  if (!response.ok) throw new Error(`OpenMeteo API request failed: ${response.status}`)
-
-  const data = await response.json()
-
-  return {
-    location,
-    temperature: { current: data.current.temperature_2m, unit: '°C' },
-    wind: { speed: data.current.windspeed_10m, unit: 'm/s', direction: null },
-    humidity: data.current.relative_humidity_2m,
-    cloudCoverage: data.current.cloudcover,
-    solarRadiation: data.current.shortwave_radiation,
-    weatherDescription: 'N/A',
-    timestamp: new Date().toISOString()
-  }
-}
-
-export async function getWeatherAroundLocation(location: Location, radius: number): Promise<WeatherAround> {
-  // 그리드 크기를 도 단위로 명확히 정의
-  const gridSizeDegrees = 0.2 // 약 22km (적도 기준)
-
-  // Open-Meteo API는 grid 파라미터에 도 단위 사용
-  const url = `${baseUrl}?latitude=${location.latitude}&longitude=${location.longitude}&grid=${gridSizeDegrees}&hourly=temperature_2m,windspeed_10m,wind_direction_10m,cloudcover,relative_humidity_2m,shortwave_radiation&timezone=UTC`
-
-  const response = await fetch(url)
-  if (!response.ok) throw new Error(`OpenMeteo API request failed: ${response.status}`)
-
-  const data = await response.json()
-  const weatherPoints = []
-
-  // 2D 격자 구성 (API 응답에서 grid_latitude와 grid_longitude 배열 사용)
-  const latitudes = data.grid_latitude || [location.latitude]
-  const longitudes = data.grid_longitude || [location.longitude]
-
-  // 2차원 그리드 구성
-  for (let latIndex = 0; latIndex < latitudes.length; latIndex++) {
-    for (let lonIndex = 0; lonIndex < longitudes.length; lonIndex++) {
-      const pointIndex = latIndex * longitudes.length + lonIndex
-
-      // 데이터 포인트가 있는 경우만 추가
-      if (data.hourly.temperature_2m[pointIndex] !== undefined) {
-        weatherPoints.push({
-          location: {
-            latitude: latitudes[latIndex],
-            longitude: longitudes[lonIndex]
-          },
-          temperature: {
-            current: data.hourly.temperature_2m[pointIndex],
-            unit: '°C'
-          },
-          wind: {
-            speed: data.hourly.windspeed_10m[pointIndex],
-            unit: 'm/s',
-            direction: data.hourly.wind_direction_10m[pointIndex]
-          },
-          humidity: data.hourly.relative_humidity_2m[pointIndex],
-          cloudCoverage: data.hourly.cloudcover[pointIndex],
-          solarRadiation: data.hourly.shortwave_radiation[pointIndex],
-          weatherDescription: 'N/A',
-          timestamp: new Date().toISOString()
-        })
-      }
-    }
-  }
-
-  return { center: location, radius, weatherPoints }
-}
-
-export async function getGlobalWeatherData(gridResolution: number = 10): Promise<WeatherAround[]> {
-  const globalWeatherData: WeatherAround[] = []
-
-  for (let lat = -90; lat <= 90; lat += gridResolution) {
-    // 위도에 따라 경도 샘플링 간격 조정
-    const lonStep = Math.max(gridResolution * Math.cos((Math.abs(lat) * Math.PI) / 180), gridResolution / 3)
-
-    for (let lon = -180; lon < 180; lon += lonStep) {
-      try {
-        const regionWeather = await getWeatherAroundLocation({ latitude: lat, longitude: lon }, gridResolution)
-        globalWeatherData.push(regionWeather)
-      } catch (error) {
-        console.error(`Failed to fetch weather for (${lat}, ${lon}):`, error)
-      }
-    }
-  }
-
-  return globalWeatherData
-}

package/server/controllers/types.ts

@@ -1,63 +0,0 @@
-/** 🌍 위치 정보 */
-export interface Location {
-  latitude: number
-  longitude: number
-}
-
-/** 🌡️ 기온 정보 */
-export interface Temperature {
-  current: number // 현재 기온
-  unit: '°C' | '°F'
-}
-
-/** 💨 바람 정보 */
-export interface Wind {
-  speed: number // 풍속
-  unit: 'm/s' | 'km/h' | 'mph'
-  direction: number | null // 풍향 (0~360도, 0=북쪽), 일부 API에서 제공되지 않을 수 있음
-}
-
-/** 🌤️ 날씨 공통 데이터 모델 */
-export interface WeatherData {
-  location: Location
-  temperature: Temperature
-  wind: Wind
-  humidity: number // 상대 습도 (%)
-  cloudCoverage: number // 구름량 (%)
-  solarRadiation: number | null // 태양광량 (W/m²), 일부 API에서 제공되지 않음
-  weatherDescription: string // 날씨 상태 (예: "clear", "partly cloudy")
-  timestamp: string // 데이터 수집 시간 (ISO8601)
-}
-
-/** 🌍 특정 위치의 주변 날씨 데이터 (여러 개의 WeatherData 포함) */
-export interface WeatherAround {
-  center: Location // 중심 좌표
-  radius: number // 반경 (km)
-  weatherPoints: WeatherData[] // 반경 내의 날씨 데이터 리스트
-}
-
-export type WeatherType = 'temperature' | 'humidity' | 'wind' | 'precipitation'
-
-export interface WeatherService {
-  /**
-   * 특정 위치의 날씨 데이터를 가져온다.
-   * @param location - 조회할 위치 (위도, 경도)
-   * @returns WeatherData - 표준화된 날씨 데이터
-   */
-  getWeatherByLocation(location: Location): Promise<WeatherData>
-
-  /**
-   * 특정 위치를 중심으로 주변 반경 내의 날씨 데이터를 가져온다.
-   * @param location - 중심 위치 (위도, 경도)
-   * @param radius - 검색할 반경 (단위: km)
-   * @returns WeatherAround - 주변의 날씨 데이터 리스트
-   */
-  getWeatherAroundLocation(location: Location, radius: number): Promise<WeatherAround>
-
-  /**
-   * 전 세계 날씨 데이터를 가져온다.
-   * @param gridResolution - 격자 크기 (단위: km)
-   * @returns WeatherAround[] - 전 세계의 날씨 데이터 리스트
-   */
-  getGlobalWeatherData(gridResolution: number): Promise<WeatherAround[]>
-}

package/server/controllers/weather-controller.ts

@@ -1,192 +0,0 @@
-import { Context } from 'koa'
-
-import { config } from '@things-factory/env'
-import { cacheService } from '@things-factory/cache-service'
-
-import { WeatherType } from './types.js'
-import { getGlobalWeatherData } from './open-meteo-adapter.js'
-import { renderWeatherMap } from '../services/chrome-renderer.js'
-
-/**
- * 전체 날씨 지도 이미지 컨트롤러
- */
-export async function globalWeatherController(ctx: Context) {
-  const type = ctx.params.type
-  const forceRefresh = ctx.query.refresh === 'true'
-
-  try {
-    // 유효한 날씨 타입인지 확인
-    if (!['temperature', 'humidity', 'wind', 'precipitation'].includes(type)) {
-      ctx.status = 400
-      ctx.body = {
-        error: `유효하지 않은 날씨 타입: ${type}`,
-        validTypes: ['temperature', 'humidity', 'wind', 'precipitation']
-      }
-      return
-    }
-
-    // 날씨 이미지 가져오기
-    const imageBuffer = await getGlobalWeatherImage(type, forceRefresh)
-
-    // 이미지 데이터 응답
-    ctx.body = Buffer.from(imageBuffer)
-
-    // 이미지 응답 헤더 설정
-    ctx.status = 200
-    ctx.set('Content-Type', 'image/png')
-    ctx.set('Cache-Control', 'public, max-age=3600') // 1시간 캐싱
-  } catch (error) {
-    console.error(`날씨 지도 생성 오류 (${type}):`, error)
-    ctx.status = 500
-    ctx.body = {
-      error: '날씨 지도 생성 중 오류가 발생했습니다',
-      message: error.message
-    }
-  }
-}
-
-/**
- * 전체 날씨 이미지 가져오기
- * @param type 날씨 타입 (temperature, humidity, wind, precipitation)
- * @param forceRefresh 캐시 무시하고 새로 가져오기
- */
-export async function getGlobalWeatherImage(type: WeatherType, forceRefresh: boolean = false): Promise<Buffer> {
-  if (!['temperature', 'humidity', 'wind', 'precipitation'].includes(type)) {
-    throw new Error(`유효하지 않은 날씨 타입: ${type}`)
-  }
-
-  // 캐시 유효 시간 (분)
-  const cacheLifetime = config.get('WEATHER_CACHE_LIFETIME') || 60
-
-  try {
-    // 캐시에서 데이터 확인
-    if (!forceRefresh) {
-      const { value: cachedDataJson } = (await cacheService.getFromCache(`global-weather-image`, { type })) || {}
-
-      // Buffer.from이 객체를 직접 처리할 수 없으므로 타입에 따라 적절하게 처리
-      let cachedData = null
-      if (cachedDataJson) {
-        if (Buffer.isBuffer(cachedDataJson)) {
-          cachedData = cachedDataJson
-        } else if (typeof cachedDataJson === 'string') {
-          // 문자열이면 버퍼로 변환
-          cachedData = cachedDataJson
-        } else if (Array.isArray(cachedDataJson)) {
-          // 배열이면 버퍼로 변환
-          cachedData = cachedDataJson
-        } else if (typeof cachedDataJson === 'object') {
-          // 객체인 경우 처리 (JSON.stringify된 버퍼일 수 있음)
-          try {
-            // JSON 문자열로 변환했다가 다시 파싱하면 배열로 변환될 수 있음
-            if ((cachedDataJson.type = 'Buffer')) {
-              cachedData = cachedDataJson.data
-            }
-          } catch (conversionError) {
-            console.error('캐시 데이터 변환 실패:', conversionError)
-          }
-        }
-      }
-
-      if (cachedData && cachedData.length > 0) {
-        console.log(`전체 날씨 이미지 캐시 사용 (타입: ${type})`)
-        return cachedData
-      }
-    }
-
-    console.log(`전체 날씨 이미지 생성 (타입: ${type})`)
-
-    var { value: weatherPoints } = (await cacheService.getFromCache(`weather-points`, {})) || {}
-
-    if (!weatherPoints || weatherPoints.length === 0) {
-      const weatherData = await getGlobalWeatherData(10)
-
-      const flattenedWeatherPoints = weatherData.reduce((acc, area) => {
-        return acc.concat(area.weatherPoints)
-      }, [])
-
-      weatherPoints = flattenedWeatherPoints.map(point => {
-        let value
-        switch (type) {
-          case 'temperature':
-            value = point.temperature?.current
-            break
-          case 'humidity':
-            value = point.humidity
-            break
-          case 'wind':
-            value = point.wind?.speed
-            break
-          case 'precipitation':
-            value = 0
-            break // 현재 데이터 없음
-        }
-
-        return {
-          lat: point.location.latitude,
-          lng: point.location.longitude,
-          value,
-          // value: point.temperature?.current,
-          description: point.weatherDescription,
-          temperature: point.temperature?.current,
-          humidity: point.humidity,
-          cloudCoverage: point.cloudCoverage,
-          solarRadiation: point.solarRadiation,
-          windSpeed: point.wind?.speed,
-          windDirection: point.wind?.direction
-          // precipitation: point.precipitation.current
-        }
-      })
-
-      await cacheService.setInCache(`weather-points`, {}, weatherPoints, cacheLifetime * 60)
-    }
-
-    // Headless Chrome으로 이미지 생성
-    const imageBuffer = await renderWeatherMap(type, weatherPoints, 1800, 900)
-
-    // 캐시에 저장 (초 단위로 TTL 설정)
-    await cacheService.setInCache(`global-weather-image`, { type }, imageBuffer, cacheLifetime * 60)
-
-    return imageBuffer
-  } catch (error) {
-    console.error(`전체 날씨 이미지 생성 실패 (타입: ${type}):`, error)
-
-    // 에러 발생 시 캐시에서 데이터 확인
-    const { value: cachedDataJson } = (await cacheService.getFromCache(`global-weather-image`, { type })) || {}
-
-    // Buffer.from이 객체를 직접 처리할 수 없으므로 타입에 따라 적절하게 처리
-    let cachedData = null
-    if (cachedDataJson) {
-      if (Buffer.isBuffer(cachedDataJson)) {
-        cachedData = cachedDataJson
-      } else if (typeof cachedDataJson === 'string') {
-        // 문자열이면 버퍼로 변환
-        cachedData = Buffer.from(cachedDataJson)
-      } else if (Array.isArray(cachedDataJson)) {
-        // 배열이면 버퍼로 변환
-        cachedData = Buffer.from(cachedDataJson)
-      } else if (typeof cachedDataJson === 'object') {
-        // 객체인 경우 처리 (JSON.stringify된 버퍼일 수 있음)
-        try {
-          // JSON 문자열로 변환했다가 다시 파싱하면 배열로 변환될 수 있음
-          const dataArray = Object.keys(cachedDataJson)
-            .filter(key => !isNaN(Number(key)))
-            .sort((a, b) => Number(a) - Number(b))
-            .map(key => cachedDataJson[key])
-
-          if (dataArray.length > 0) {
-            cachedData = Buffer.from(dataArray)
-          }
-        } catch (conversionError) {
-          console.error('캐시 데이터 변환 실패:', conversionError)
-        }
-      }
-    }
-
-    if (cachedData) {
-      console.log(`에러로 인해 캐시된 날씨 이미지 사용 (타입: ${type})`)
-      return cachedData
-    }
-
-    throw error
-  }
-}

package/server/index.ts

@@ -1 +0,0 @@
-import './routes'

package/server/routers/geo-router.ts

@@ -1,297 +0,0 @@
-/**
- * @fileoverview
- * Koa 기반의 GeoJSON → MBTiles 변환 및 VectorTile(MVT) 서비스 제공 라우터
- *
- * 이 라우터는 GeoJSON 데이터를 MBTiles 형식으로 변환하고, OpenLayers 등의 클라이언트에서
- * Vector Tile(MVT) 형식으로 요청할 수 있도록 API 엔드포인트를 제공합니다.
- *
- * 📌 주요 기능:
- * 1️⃣ `/tiles/regenerate`  (POST) → GeoJSON을 다시 MBTiles로 변환
- * 2️⃣ `/tiles/:z/:x/:y.mvt` (GET) → 특정 타일 데이터를 반환
- * 3️⃣ `/tiles/metadata`  (GET) → MBTiles의 메타데이터 반환
- *
- * 🚀 서비스 초기화 흐름:
- * 1. 서버 시작 시 `initializeTileService()` 호출
- *    - MBTiles 파일이 없으면 `convertGeoJsonToMBTiles()` 실행하여 생성
- *    - MBTiles가 존재하면 `loadTileSource()`를 호출하여 데이터 로드
- * 2. 클라이언트가 MVT 타일을 요청하면 `tileSource.getTile(z, x, y, callback)`을 통해 데이터 반환
- *
- * 📌 주요 처리 로직:
- * ✅ **GeoJSON → MBTiles 변환 (`convertGeoJsonToMBTiles`)**
- *    - `tippecanoe` CLI를 사용하여 GeoJSON을 MBTiles로 변환
- *    - 기존 MBTiles 파일이 있으면 삭제 후 재생성
- *    - `spawn`을 사용하여 비동기적으로 실행하며 로그 출력
- *
- * ✅ **MBTiles 파일을 로드 (`loadTileSource`)**
- *    - `@mapbox/mbtiles` 라이브러리를 사용하여 MBTiles 데이터베이스를 로드
- *    - 타일 요청이 있을 때 해당 타일을 `tileSource.getTile()`을 통해 제공
- *
- * ✅ **타일 요청 처리 (`/tiles/:z/:x/:y.mvt`)**
- *    - MBTiles에서 특정 타일을 찾아 바이너리 MVT 데이터로 반환
- *    - `Content-Encoding: gzip` 설정으로 압축된 타일 제공
- *    - `TMS 좌표 변환` 문제 제거하여 직접 요청 가능하도록 개선
- *
- * ✅ **타일셋 메타데이터 반환 (`/tiles/metadata`)**
- *    - MBTiles 파일에서 메타데이터 정보를 가져와 JSON 형태로 반환
- *
- * 📌 종속성:
- * - `koa-router`: Koa 기반 API 라우팅
- * - `fs`, `path`: 파일 시스템 접근 및 경로 처리
- * - `child_process`, `util`: `tippecanoe` 실행을 위한 비동기 프로세스 실행
- * - `@mapbox/mbtiles`: MBTiles 데이터베이스 접근 라이브러리
- * - `@things-factory/env`: 환경 변수 관리
- *
- * 📌 디렉토리 구조:
- * ```
- * /cache/mvt-tiles/        # 생성된 MBTiles 저장
- * /data/geo-json/          # 원본 GeoJSON 파일 저장
- * ```
- *
- * 📌 실행 방법:
- * 1. GeoJSON 데이터 준비
- * 2. Koa 서버 실행 → 자동으로 MBTiles 변환 후 서비스 시작
- * 3. 클라이언트(OpenLayers 등)에서 VectorTile 요청 가능
- * 4. 필요 시 `/tiles/regenerate` 엔드포인트로 타일 재생성
- *
- * @module geoRouter
- */
-
-import Router from 'koa-router'
-import * as fs from 'fs'
-import * as path from 'path'
-import * as child_process from 'child_process'
-import * as util from 'util'
-import { config } from '@things-factory/env'
-import mbtiles from '@mapbox/mbtiles'
-
-const exec = util.promisify(child_process.exec)
-
-export const geoRouter = new Router()
-
-const TILE_CACHE_DIR = path.resolve(config.get('directory', './cache'), 'mvt-tiles')
-const GEO_DATA_DIR = path.resolve(__dirname, '..', '..', 'data', 'geo-json')
-
-if (!fs.existsSync(TILE_CACHE_DIR)) {
-  fs.mkdirSync(TILE_CACHE_DIR, { recursive: true })
-}
-if (!fs.existsSync(GEO_DATA_DIR)) {
-  fs.mkdirSync(GEO_DATA_DIR, { recursive: true })
-}
-
-const COUNTRIES_GEO_JSON = path.resolve(GEO_DATA_DIR, 'countries-max-geo.json')
-const MBTILES_PATH = path.resolve(TILE_CACHE_DIR, 'countries.mbtiles')
-
-import { spawn } from 'child_process'
-
-const convertGeoJsonToMBTiles = async () => {
-  // tippecanoe -o ./packages/operato-ecs/cache/mvt-tiles/countries.mbtiles -z10 -Z5 --force  --maximum-zoom=10 --minimum-zoom=0 --drop-smallest-as-needed --layer=countries ./packages/weather/data/geo-json/countries-max-geo.json
-  try {
-    if (!fs.existsSync(COUNTRIES_GEO_JSON)) {
-      console.error('GeoJSON 파일을 찾을 수 없습니다:', COUNTRIES_GEO_JSON)
-      return false
-    }
-
-    if (fs.existsSync(MBTILES_PATH)) {
-      fs.unlinkSync(MBTILES_PATH)
-      console.log('기존 MBTiles 파일 삭제됨')
-    }
-
-    const tippecanoeCmd = [
-      '-o',
-      MBTILES_PATH,
-      '-z10',
-      '-Z5',
-      '--force',
-      '--maximum-zoom=10',
-      '--minimum-zoom=0',
-      '--drop-smallest-as-needed',
-      '--layer=countries',
-      COUNTRIES_GEO_JSON
-    ]
-
-    console.log('Tippecanoe 명령 실행 중...')
-    console.log(`tippecanoe ${tippecanoeCmd.join(' ')}`)
-
-    return new Promise((resolve, reject) => {
-      const process = spawn('tippecanoe', tippecanoeCmd)
-
-      process.stdout.on('data', data => {
-        console.log(`[tippecanoe]: ${data.toString()}`)
-      })
-
-      process.stderr.on('data', data => {
-        console.error(`[tippecanoe ERROR]: ${data.toString()}`)
-      })
-
-      process.on('close', code => {
-        if (code === 0) {
-          console.log('MBTiles 변환 완료 ✅')
-          resolve(true)
-        } else {
-          console.error(`Tippecanoe 종료 코드: ${code}`)
-          resolve(false)
-        }
-      })
-
-      process.on('error', err => {
-        console.error(`Tippecanoe 실행 오류: ${err}`)
-        reject(err)
-      })
-    })
-  } catch (error) {
-    console.error('MBTiles 변환 오류:', error)
-    return false
-  }
-}
-
-// MBTiles 소스
-let tileSource = null
-
-// MBTiles 소스 로드
-const loadTileSource = async () => {
-  if (tileSource) return tileSource
-
-  return new Promise((resolve, reject) => {
-    new mbtiles(`mbtiles://${MBTILES_PATH}`, (err, source) => {
-      if (err) {
-        console.error('MBTiles 로드 오류:', err)
-        return reject(err)
-      }
-
-      tileSource = source
-      console.log('MBTiles 소스 로드 완료')
-      resolve(source)
-    })
-  })
-}
-
-// 타일 서비스 초기화
-const initializeTileService = async () => {
-  try {
-    // MBTiles 파일이 없으면 생성
-    if (!fs.existsSync(MBTILES_PATH)) {
-      console.log('MBTiles 파일이 없습니다. 생성을 시작합니다...')
-      const result = await convertGeoJsonToMBTiles()
-      if (!result) return false
-    }
-
-    // MBTiles 소스 로드
-    await loadTileSource()
-    return true
-  } catch (error) {
-    console.error('타일 서비스 초기화 오류:', error)
-    return false
-  }
-}
-
-// API 엔드포인트: 타일 재생성 트리거
-geoRouter.post('/tiles/regenerate', async ctx => {
-  try {
-    console.log('타일 재생성 요청 받음')
-    const result = await convertGeoJsonToMBTiles()
-
-    if (result) {
-      // 새 타일소스 로드
-      await loadTileSource()
-      ctx.body = { success: true, message: 'MBTiles 타일 생성 완료' }
-    } else {
-      ctx.status = 500
-      ctx.body = { success: false, message: 'MBTiles 타일 생성 실패' }
-    }
-  } catch (error) {
-    console.error('타일 재생성 오류:', error)
-    ctx.status = 500
-    ctx.body = { success: false, message: '서버 오류 발생' }
-  }
-})
-
-geoRouter.get('/tiles/:z/:x/:y.mvt', async ctx => {
-  try {
-    const z = parseInt(ctx.params.z, 10)
-    const x = parseInt(ctx.params.x, 10)
-    const y = parseInt(ctx.params.y, 10)
-
-    // 타일 서비스 로드 확인
-    if (!tileSource) {
-      console.log(`🚀 타일 서비스 로드 중...`)
-      const initialized = await initializeTileService()
-      if (!initialized) {
-        ctx.status = 500
-        ctx.body = { error: '타일 서비스를 초기화할 수 없습니다.' }
-        return
-      }
-    }
-
-    await new Promise((resolve, reject) => {
-      tileSource.getTile(z, x, y, (err, data, headers) => {
-        if (err) {
-          if (err.message.includes('Tile does not exist')) {
-            ctx.status = 204
-            console.log(`🚨 타일 없음: z=${z}, x=${x}, y=${y}`)
-            return resolve(null)
-          }
-
-          console.error(`❌ 타일 로드 오류 (z:${z}, x:${x}, y:${y}):`, err)
-          ctx.status = 500
-          ctx.body = { error: '타일을 로드할 수 없습니다.' }
-          return resolve(null)
-        }
-
-        ctx.set('Content-Type', headers['Content-Type'] || 'application/x-protobuf')
-        ctx.set({
-          'Access-Control-Allow-Origin': '*',
-          'Cache-Control': 'no-cache, no-store, must-revalidate, proxy-revalidate',
-          'Content-Encoding': 'gzip'
-        })
-
-        ctx.body = data
-        resolve(null)
-      })
-    })
-  } catch (error) {
-    console.error('❌ 타일 서비스 오류:', error)
-    ctx.status = 500
-    ctx.body = { error: '서버 오류가 발생했습니다.' }
-  }
-})
-
-geoRouter.get('/tiles/metadata', async ctx => {
-  try {
-    if (!tileSource) {
-      const initialized = await initializeTileService()
-      if (!initialized) {
-        ctx.status = 500
-        ctx.body = { error: '타일 서비스를 초기화할 수 없습니다.' }
-        return
-      }
-    }
-
-    await new Promise((resolve, reject) => {
-      tileSource.getInfo((err, info) => {
-        if (err) {
-          console.error('메타데이터 로드 오류:', err)
-          ctx.status = 500
-          ctx.body = { error: '메타데이터를 로드할 수 없습니다.' }
-          return resolve(null)
-        }
-
-        ctx.body = info
-        resolve(null)
-      })
-    })
-  } catch (error) {
-    console.error('메타데이터 서비스 오류:', error)
-    ctx.status = 500
-    ctx.body = { error: '서버 오류가 발생했습니다.' }
-  }
-})
-
-initializeTileService().then(success => {
-  if (success) {
-    console.log('🗺️ 타일 서비스가 준비되었습니다.')
-  } else {
-    console.error('❌ 타일 서비스 초기화에 실패했습니다.')
-  }
-})
-
-export default geoRouter