daiso 1.0.4 → 1.0.6

package/dist/api/lottemartHandlers.js

@@ -0,0 +1,144 @@
+/**
+ * 롯데마트 GET API 핸들러
+ */
+import { errorResponse, successResponse } from './response.js';
+import { fetchLotteMartStores, searchLotteMartProducts } from '../services/lottemart/client.js';
+import { DEFAULT_LOTTEMART_TIMEOUT_MS } from '../services/lottemart/config.js';
+import { probeLotteMartUpstream } from '../services/lottemart/debug.js';
+function parseLotteMartProductSource(value) {
+    if (!value || value === 'auto') {
+        return 'auto';
+    }
+    if (value === 'legacy' || value === 'zetta') {
+        return value;
+    }
+    return null;
+}
+/**
+ * 롯데마트 매장 검색 API 핸들러
+ * GET /api/lottemart/stores?keyword={키워드}&lat={위도}&lng={경도}
+ */
+export async function handleLotteMartFindStores(c) {
+    const keyword = c.req.query('keyword') || '';
+    const area = c.req.query('area') || '';
+    const brandVariant = c.req.query('brandVariant') || '';
+    const limit = parseInt(c.req.query('limit') || '20', 10);
+    const rawLat = c.req.query('lat');
+    const rawLng = c.req.query('lng');
+    const parsedLat = rawLat ? parseFloat(rawLat) : undefined;
+    const parsedLng = rawLng ? parseFloat(rawLng) : undefined;
+    const latitude = typeof parsedLat === 'number' && Number.isFinite(parsedLat) ? parsedLat : undefined;
+    const longitude = typeof parsedLng === 'number' && Number.isFinite(parsedLng) ? parsedLng : undefined;
+    try {
+        const result = await fetchLotteMartStores({
+            area,
+            keyword,
+            brandVariant,
+            latitude,
+            longitude,
+            limit,
+        }, {
+            timeout: DEFAULT_LOTTEMART_TIMEOUT_MS,
+            googleMapsApiKey: c.env?.GOOGLE_MAPS_API_KEY,
+            zyteApiKey: c.env?.ZYTE_API_KEY,
+        });
+        return successResponse(c, {
+            area: area || null,
+            keyword,
+            brandVariant: brandVariant || null,
+            geocodeUsed: result.geocodeUsed,
+            location: result.location,
+            count: result.stores.length,
+            stores: result.stores,
+        }, {
+            total: result.stores.length,
+            page: 1,
+            pageSize: limit,
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : '알 수 없는 오류가 발생했습니다.';
+        return errorResponse(c, 'LOTTEMART_STORE_SEARCH_FAILED', message, 500);
+    }
+}
+/**
+ * 롯데마트 상품 검색 API 핸들러
+ * GET /api/lottemart/products?keyword={검색어}&storeCode={매장코드}
+ */
+export async function handleLotteMartSearchProducts(c) {
+    const keyword = c.req.query('keyword') || '';
+    const area = c.req.query('area') || '';
+    const storeCode = c.req.query('storeCode') || '';
+    const storeName = c.req.query('storeName') || '';
+    const pageLimit = parseInt(c.req.query('pageLimit') || '3', 10);
+    const parsedTimeoutMs = parseInt(c.req.query('timeoutMs') || String(DEFAULT_LOTTEMART_TIMEOUT_MS), 10);
+    const timeoutMs = Number.isFinite(parsedTimeoutMs) && parsedTimeoutMs > 0 ? parsedTimeoutMs : DEFAULT_LOTTEMART_TIMEOUT_MS;
+    const source = parseLotteMartProductSource(c.req.query('source'));
+    if (keyword.trim().length === 0) {
+        return errorResponse(c, 'MISSING_QUERY', '검색어(keyword)를 입력해주세요.');
+    }
+    if (!source) {
+        return errorResponse(c, 'INVALID_LOTTEMART_SOURCE', 'source는 auto, legacy, zetta 중 하나여야 합니다.');
+    }
+    if (storeCode.trim().length === 0 && storeName.trim().length === 0) {
+        return errorResponse(c, 'MISSING_STORE', 'storeCode 또는 storeName 중 하나를 입력해주세요.');
+    }
+    try {
+        const result = await searchLotteMartProducts({
+            area,
+            storeCode,
+            storeName,
+            keyword,
+            pageLimit,
+            source,
+        }, {
+            timeout: timeoutMs,
+            zyteApiKey: c.env?.ZYTE_API_KEY,
+        });
+        return successResponse(c, {
+            area: result.area,
+            storeCode: result.storeCode,
+            storeName: result.storeName,
+            keyword,
+            pageLimit,
+            totalPages: result.totalPages,
+            products: result.products,
+        }, {
+            total: result.totalCount,
+            page: 1,
+            pageSize: result.products.length,
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : '알 수 없는 오류가 발생했습니다.';
+        return errorResponse(c, 'LOTTEMART_PRODUCT_SEARCH_FAILED', message, 500);
+    }
+}
+/**
+ * 롯데마트 업스트림 단독 진단 API 핸들러
+ * GET /api/lottemart/debug?target=market-options|stores|products|product-page
+ */
+export async function handleLotteMartDebug(c) {
+    const target = (c.req.query('target') || '');
+    const allowedTargets = ['market-options', 'stores', 'products', 'product-page'];
+    if (!allowedTargets.includes(target)) {
+        return errorResponse(c, 'INVALID_TARGET', 'target은 market-options, stores, products, product-page 중 하나여야 합니다.');
+    }
+    try {
+        const result = await probeLotteMartUpstream({
+            target,
+            area: c.req.query('area') || undefined,
+            type: (c.req.query('type') || undefined),
+            storeCode: c.req.query('storeCode') || undefined,
+            keyword: c.req.query('keyword') || undefined,
+            page: c.req.query('page') ? parseInt(c.req.query('page'), 10) : undefined,
+            timeout: c.req.query('timeoutMs') ? parseInt(c.req.query('timeoutMs'), 10) : DEFAULT_LOTTEMART_TIMEOUT_MS,
+            zyteApiKey: c.env?.ZYTE_API_KEY,
+        });
+        return successResponse(c, result);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : '알 수 없는 오류가 발생했습니다.';
+        return errorResponse(c, 'LOTTEMART_DEBUG_FAILED', message, 500);
+    }
+}

package/dist/api/megaboxHandlers.js

@@ -1,63 +1,42 @@
 /**
  * 메가박스 GET API 핸들러
  */
-import { fetchMegaboxBookingList, fetchMegaboxTheaterInfo, toYyyymmdd, } from '../services/megabox/client.js';
+import { fetchMegaboxBookingList, toYyyymmdd } from '../services/megabox/client.js';
+import { fetchMegaboxNearbyTheaters, resolveMegaboxNearestTheater } from '../services/megabox/location.js';
 import { errorResponse, successResponse } from './response.js';
-function calculateDistanceKm(lat1, lng1, lat2, lng2) {
-    const toRad = (deg) => (deg * Math.PI) / 180;
-    const dLat = toRad(lat2 - lat1);
-    const dLng = toRad(lng2 - lng1);
-    const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
-        Math.cos(toRad(lat1)) * Math.cos(toRad(lat2)) * Math.sin(dLng / 2) * Math.sin(dLng / 2);
-    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
-    return 6371 * c;
+function parseOptionalNumber(value) {
+    if (!value) {
+        return undefined;
+    }
+    const parsed = Number.parseFloat(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
 }
 /**
  * 메가박스 주변 지점 조회 API 핸들러
  * GET /api/megabox/theaters?lat={위도}&lng={경도}&playDate={YYYYMMDD}&areaCode={지역코드}
  */
 export async function handleMegaboxFindNearbyTheaters(c) {
-    const lat = parseFloat(c.req.query('lat') || '37.5665');
-    const lng = parseFloat(c.req.query('lng') || '126.978');
+    const keyword = c.req.query('keyword') || undefined;
+    const lat = parseOptionalNumber(c.req.query('lat'));
+    const lng = parseOptionalNumber(c.req.query('lng'));
     const playDate = c.req.query('playDate') || toYyyymmdd();
-    const areaCode = c.req.query('areaCode') || '11';
+    const areaCode = c.req.query('areaCode') || undefined;
     const limit = parseInt(c.req.query('limit') || '10');
     const timeoutMs = parseInt(c.req.query('timeoutMs') || '15000');
     try {
-        const { theaters } = await fetchMegaboxBookingList({
+        const result = await fetchMegaboxNearbyTheaters({
+            keyword,
+            latitude: lat,
+            longitude: lng,
             playDate,
             areaCode,
+            limit,
+            timeout: timeoutMs,
+        }, {
+            googleMapsApiKey: c.env?.GOOGLE_MAPS_API_KEY,
             timeout: timeoutMs,
         });
-        const infoResults = await Promise.allSettled(theaters.map((theater) => fetchMegaboxTheaterInfo(theater.theaterId, timeoutMs)));
-        const merged = theaters
-            .map((theater, index) => {
-            const infoResult = infoResults[index];
-            if (infoResult.status !== 'fulfilled') {
-                return null;
-            }
-            if (infoResult.value.latitude === null || infoResult.value.longitude === null) {
-                return null;
-            }
-            const distanceKm = calculateDistanceKm(lat, lng, infoResult.value.latitude, infoResult.value.longitude);
-            return {
-                theaterId: theater.theaterId,
-                theaterName: theater.theaterName,
-                address: infoResult.value.address,
-                latitude: infoResult.value.latitude,
-                longitude: infoResult.value.longitude,
-                distanceKm: Number(distanceKm.toFixed(2)),
-            };
-        })
-            .filter((theater) => theater !== null)
-            .sort((a, b) => a.distanceKm - b.distanceKm)
-            .slice(0, limit);
-        return successResponse(c, {
-            location: { latitude: lat, longitude: lng },
-            playDate,
-            areaCode,
-            theaters: merged,
-        }, { total: merged.length, pageSize: limit });
+        return successResponse(c, result, { total: result.count, pageSize: limit });
     }
     catch (error) {
         const message = error instanceof Error ? error.message : '알 수 없는 오류가 발생했습니다.';
@@ -70,16 +49,38 @@ export async function handleMegaboxFindNearbyTheaters(c) {
  */
 export async function handleMegaboxListNowShowing(c) {
     const playDate = c.req.query('playDate') || toYyyymmdd();
-    const theaterId = c.req.query('theaterId') || undefined;
+    const keyword = c.req.query('keyword') || undefined;
+    const lat = parseOptionalNumber(c.req.query('lat'));
+    const lng = parseOptionalNumber(c.req.query('lng'));
+    let theaterId = c.req.query('theaterId') || undefined;
     const movieId = c.req.query('movieId') || undefined;
-    const areaCode = c.req.query('areaCode') || '11';
+    const areaCode = c.req.query('areaCode') || undefined;
     const timeoutMs = parseInt(c.req.query('timeoutMs') || '15000');
     try {
+        let resolvedTheater = null;
+        let resolvedLocation = null;
+        if (!theaterId && (keyword || typeof lat === 'number' || typeof lng === 'number')) {
+            const resolved = await resolveMegaboxNearestTheater({
+                keyword,
+                latitude: lat,
+                longitude: lng,
+                areaCode,
+                playDate,
+                timeout: timeoutMs,
+            }, {
+                googleMapsApiKey: c.env?.GOOGLE_MAPS_API_KEY,
+                timeout: timeoutMs,
+            });
+            theaterId = resolved.theater?.theaterId;
+            resolvedTheater = resolved.theater;
+            resolvedLocation = resolved.location;
+        }
+        const resolvedAreaCode = resolvedLocation?.areaCode || areaCode || '11';
         const result = await fetchMegaboxBookingList({
             playDate,
             theaterId,
             movieId,
-            areaCode,
+            areaCode: resolvedAreaCode,
             timeout: timeoutMs,
         });
         return successResponse(c, {
@@ -87,8 +88,12 @@ export async function handleMegaboxListNowShowing(c) {
             filters: {
                 theaterId: theaterId || null,
                 movieId: movieId || null,
-                areaCode,
+                keyword: keyword || null,
+                latitude: lat ?? null,
+                longitude: lng ?? null,
+                areaCode: resolvedAreaCode,
             },
+            resolvedTheater,
             theaters: result.theaters,
             movies: result.movies,
             showtimes: result.showtimes,
@@ -105,17 +110,39 @@ export async function handleMegaboxListNowShowing(c) {
  */
 export async function handleMegaboxGetRemainingSeats(c) {
     const playDate = c.req.query('playDate') || toYyyymmdd();
-    const theaterId = c.req.query('theaterId') || undefined;
+    const keyword = c.req.query('keyword') || undefined;
+    const lat = parseOptionalNumber(c.req.query('lat'));
+    const lng = parseOptionalNumber(c.req.query('lng'));
+    let theaterId = c.req.query('theaterId') || undefined;
     const movieId = c.req.query('movieId') || undefined;
-    const areaCode = c.req.query('areaCode') || '11';
+    const areaCode = c.req.query('areaCode') || undefined;
     const limit = parseInt(c.req.query('limit') || '50');
     const timeoutMs = parseInt(c.req.query('timeoutMs') || '15000');
     try {
+        let resolvedTheater = null;
+        let resolvedLocation = null;
+        if (!theaterId && (keyword || typeof lat === 'number' || typeof lng === 'number')) {
+            const resolved = await resolveMegaboxNearestTheater({
+                keyword,
+                latitude: lat,
+                longitude: lng,
+                areaCode,
+                playDate,
+                timeout: timeoutMs,
+            }, {
+                googleMapsApiKey: c.env?.GOOGLE_MAPS_API_KEY,
+                timeout: timeoutMs,
+            });
+            theaterId = resolved.theater?.theaterId;
+            resolvedTheater = resolved.theater;
+            resolvedLocation = resolved.location;
+        }
+        const resolvedAreaCode = resolvedLocation?.areaCode || areaCode || '11';
         const { showtimes } = await fetchMegaboxBookingList({
             playDate,
             theaterId,
             movieId,
-            areaCode,
+            areaCode: resolvedAreaCode,
             timeout: timeoutMs,
         });
         const seats = showtimes
@@ -133,8 +160,12 @@ export async function handleMegaboxGetRemainingSeats(c) {
             filters: {
                 theaterId: theaterId || null,
                 movieId: movieId || null,
-                areaCode,
+                keyword: keyword || null,
+                latitude: lat ?? null,
+                longitude: lng ?? null,
+                areaCode: resolvedAreaCode,
             },
+            resolvedTheater,
             seats,
         }, { total: seats.length, pageSize: limit });
     }

package/dist/api/response.js

@@ -1,6 +1,7 @@
 /**
  * API 공통 응답 유틸리티
  */
+import { toStandardErrorDiagnostics } from '../core/errors.js';
 /**
  * 성공 응답 생성
  */
@@ -18,5 +19,6 @@ export function errorResponse(c, code, message, status = 400) {
     return c.json({
         success: false,
         error: { code, message },
+        diagnostics: toStandardErrorDiagnostics(code, message, { status }),
     }, status);
 }

package/dist/api/routes/cuRoutes.js

@@ -0,0 +1,17 @@
+/**
+ * CU GET API 라우트 등록
+ */
+import { withEdgeCache } from '../../utils/cache.js';
+import { handleCuFindStores, handleCuCheckInventory } from '../handlers.js';
+export function registerCuRoutes(app) {
+    app.get('/api/cu/stores', async (c) => withEdgeCache(c.req.url, {
+        ttlSeconds: 60 * 60 * 24,
+        staleWhileRevalidateSeconds: 60 * 5,
+        keyPrefix: 'cu-stores-v1',
+    }, () => handleCuFindStores(c)));
+    app.get('/api/cu/inventory', async (c) => withEdgeCache(c.req.url, {
+        ttlSeconds: 60 * 10,
+        staleWhileRevalidateSeconds: 60,
+        keyPrefix: 'cu-inventory-v1',
+    }, () => handleCuCheckInventory(c)));
+}

package/dist/api/routes/daisoRoutes.js

@@ -2,7 +2,7 @@
  * 다이소 GET API 라우트 등록
  */
 import { withEdgeCache } from '../../utils/cache.js';
-import { handleSearchProducts, handleGetProduct, handleFindStores, handleCheckInventory, } from '../handlers.js';
+import { handleSearchProducts, handleGetProduct, handleFindStores, handleCheckInventory, handleGetDisplayLocation, } from '../handlers.js';
 export function registerDaisoRoutes(app) {
     app.get('/api/daiso/products', async (c) => withEdgeCache(c.req.url, {
         ttlSeconds: 60 * 30,
@@ -24,4 +24,9 @@ export function registerDaisoRoutes(app) {
         staleWhileRevalidateSeconds: 60,
         keyPrefix: 'daiso-inventory-v1',
     }, () => handleCheckInventory(c)));
+    app.get('/api/daiso/display-location', async (c) => withEdgeCache(c.req.url, {
+        ttlSeconds: 60 * 10,
+        staleWhileRevalidateSeconds: 60,
+        keyPrefix: 'daiso-display-location-v1',
+    }, () => handleGetDisplayLocation(c)));
 }

package/dist/api/routes/emart24Routes.js

@@ -0,0 +1,22 @@
+/**
+ * 이마트24 GET API 라우트 등록
+ */
+import { withEdgeCache } from '../../utils/cache.js';
+import { handleEmart24CheckInventory, handleEmart24FindStores, handleEmart24SearchProducts, } from '../emart24Handlers.js';
+export function registerEmart24Routes(app) {
+    app.get('/api/emart24/stores', async (c) => withEdgeCache(c.req.url, {
+        ttlSeconds: 60 * 30,
+        staleWhileRevalidateSeconds: 60 * 3,
+        keyPrefix: 'emart24-stores-v1',
+    }, () => handleEmart24FindStores(c)));
+    app.get('/api/emart24/products', async (c) => withEdgeCache(c.req.url, {
+        ttlSeconds: 60 * 10,
+        staleWhileRevalidateSeconds: 60,
+        keyPrefix: 'emart24-products-v1',
+    }, () => handleEmart24SearchProducts(c)));
+    app.get('/api/emart24/inventory', async (c) => withEdgeCache(c.req.url, {
+        ttlSeconds: 60 * 5,
+        staleWhileRevalidateSeconds: 60,
+        keyPrefix: 'emart24-inventory-v1',
+    }, () => handleEmart24CheckInventory(c)));
+}

package/dist/api/routes/gs25Routes.js

@@ -0,0 +1,22 @@
+/**
+ * GS25 GET API 라우트 등록
+ */
+import { withEdgeCache } from '../../utils/cache.js';
+import { handleGs25CheckInventory, handleGs25FindStores, handleGs25SearchProducts, } from '../gs25Handlers.js';
+export function registerGs25Routes(app) {
+    app.get('/api/gs25/stores', async (c) => withEdgeCache(c.req.url, {
+        ttlSeconds: 60 * 10,
+        staleWhileRevalidateSeconds: 60,
+        keyPrefix: 'gs25-stores-v1',
+    }, () => handleGs25FindStores(c)));
+    app.get('/api/gs25/products', async (c) => withEdgeCache(c.req.url, {
+        ttlSeconds: 60 * 3,
+        staleWhileRevalidateSeconds: 60,
+        keyPrefix: 'gs25-products-v1',
+    }, () => handleGs25SearchProducts(c)));
+    app.get('/api/gs25/inventory', async (c) => withEdgeCache(c.req.url, {
+        ttlSeconds: 60 * 2,
+        staleWhileRevalidateSeconds: 30,
+        keyPrefix: 'gs25-inventory-v1',
+    }, () => handleGs25CheckInventory(c)));
+}

package/dist/api/routes/healthRoutes.js

@@ -0,0 +1,61 @@
+/**
+ * 운영용 상세 헬스 체크 라우트
+ */
+import { errorResponse } from '../response.js';
+import { runHealthChecks } from '../healthChecks.js';
+function parseBoolean(value) {
+    const normalized = (value || '').trim().toLowerCase();
+    return normalized === 'true' || normalized === '1' || normalized === 'y';
+}
+function readHealthCheckToken(headers) {
+    const authorization = headers.get('Authorization') || '';
+    if (authorization.toLowerCase().startsWith('bearer ')) {
+        return authorization.slice('bearer '.length).trim();
+    }
+    return (headers.get('x-health-check-key') || '').trim();
+}
+function parseMode(value) {
+    if (!value || value === 'quick') {
+        return 'quick';
+    }
+    if (value === 'deep' || value === 'full') {
+        return value;
+    }
+    return null;
+}
+export function registerHealthRoutes(app) {
+    app.get('/api/health/checks', async (c) => {
+        const secret = c.env?.HEALTH_CHECK_SECRET?.trim();
+        if (!secret) {
+            return errorResponse(c, 'HEALTH_CHECK_SECRET_NOT_CONFIGURED', 'HEALTH_CHECK_SECRET이 설정되어 있지 않습니다.', 503);
+        }
+        if (readHealthCheckToken(c.req.raw.headers) !== secret) {
+            return errorResponse(c, 'UNAUTHORIZED_HEALTH_CHECK', '유효한 헬스 체크 시크릿 키가 필요합니다.', 401);
+        }
+        const mode = parseMode(c.req.query('mode'));
+        if (!mode) {
+            return errorResponse(c, 'INVALID_HEALTH_CHECK_MODE', 'mode는 quick, deep, full 중 하나여야 합니다.', 400);
+        }
+        const timeoutMs = Number.parseInt(c.req.query('timeoutMs') || '3000', 10);
+        const slowThresholdMs = Number.parseInt(c.req.query('slowThresholdMs') || c.env?.HEALTH_CHECK_SLOW_THRESHOLD_MS || '0', 10);
+        const baseUrl = c.req.query('baseUrl')?.trim() || c.env?.HEALTH_CHECK_BASE_URL?.trim() || new URL(c.req.url).origin;
+        const transport = c.req.query('transport') || c.env?.HEALTH_CHECK_TRANSPORT || 'internal';
+        const cacheBust = parseBoolean(c.req.query('cacheBust')) || transport === 'network';
+        const fetchImpl = c.env?.HEALTH_CHECK_BASE_URL && transport !== 'network'
+            ? async (input, init) => app.fetch(new Request(input, init), c.env)
+            : undefined;
+        const result = await runHealthChecks({
+            baseUrl,
+            service: c.req.query('service') || undefined,
+            check: c.req.query('check') || undefined,
+            mode,
+            timeoutMs,
+            slowThresholdMs,
+            includeSamples: parseBoolean(c.req.query('includeSamples')),
+            fresh: parseBoolean(c.req.query('fresh')),
+            cacheBust,
+            fetchImpl,
+        });
+        return c.json(result);
+    });
+}

package/dist/api/routes/lottecinemaRoutes.js

@@ -0,0 +1,22 @@
+/**
+ * 롯데시네마 GET API 라우트 등록
+ */
+import { withEdgeCache } from '../../utils/cache.js';
+import { handleLotteCinemaFindNearbyTheaters, handleLotteCinemaGetRemainingSeats, handleLotteCinemaListNowShowing, } from '../lottecinemaHandlers.js';
+export function registerLotteCinemaRoutes(app) {
+    app.get('/api/lottecinema/theaters', async (c) => withEdgeCache(c.req.url, {
+        ttlSeconds: 60 * 60 * 24,
+        staleWhileRevalidateSeconds: 60 * 5,
+        keyPrefix: 'lottecinema-theaters-v1',
+    }, () => handleLotteCinemaFindNearbyTheaters(c)));
+    app.get('/api/lottecinema/movies', async (c) => withEdgeCache(c.req.url, {
+        ttlSeconds: 60 * 10,
+        staleWhileRevalidateSeconds: 60,
+        keyPrefix: 'lottecinema-movies-v1',
+    }, () => handleLotteCinemaListNowShowing(c)));
+    app.get('/api/lottecinema/seats', async (c) => withEdgeCache(c.req.url, {
+        ttlSeconds: 60 * 3,
+        staleWhileRevalidateSeconds: 30,
+        keyPrefix: 'lottecinema-seats-v1',
+    }, () => handleLotteCinemaGetRemainingSeats(c)));
+}

package/dist/api/routes/lottemartRoutes.js

@@ -0,0 +1,18 @@
+/**
+ * 롯데마트 GET API 라우트 등록
+ */
+import { withEdgeCache } from '../../utils/cache.js';
+import { handleLotteMartDebug, handleLotteMartFindStores, handleLotteMartSearchProducts } from '../lottemartHandlers.js';
+export function registerLotteMartRoutes(app) {
+    app.get('/api/lottemart/stores', async (c) => withEdgeCache(c.req.url, {
+        ttlSeconds: 60 * 30,
+        staleWhileRevalidateSeconds: 60 * 3,
+        keyPrefix: 'lottemart-stores-v1',
+    }, () => handleLotteMartFindStores(c)));
+    app.get('/api/lottemart/products', async (c) => withEdgeCache(c.req.url, {
+        ttlSeconds: 60 * 5,
+        staleWhileRevalidateSeconds: 60,
+        keyPrefix: 'lottemart-products-v1',
+    }, () => handleLotteMartSearchProducts(c)));
+    app.get('/api/lottemart/debug', (c) => handleLotteMartDebug(c));
+}

package/dist/api/routes/oliveyoungRoutes.js

@@ -2,8 +2,13 @@
  * 올리브영 GET API 라우트 등록
  */
 import { withEdgeCache } from '../../utils/cache.js';
-import { handleOliveyoungFindStores, handleOliveyoungCheckInventory } from '../handlers.js';
+import { handleOliveyoungFindStores, handleOliveyoungCheckInventory, handleOliveyoungSearchProducts, } from '../handlers.js';
 export function registerOliveyoungRoutes(app) {
+    app.get('/api/oliveyoung/products', async (c) => withEdgeCache(c.req.url, {
+        ttlSeconds: 60 * 5,
+        staleWhileRevalidateSeconds: 60,
+        keyPrefix: 'oliveyoung-products-v1',
+    }, () => handleOliveyoungSearchProducts(c)));
     app.get('/api/oliveyoung/stores', async (c) => withEdgeCache(c.req.url, {
         ttlSeconds: 60 * 60 * 24,
         staleWhileRevalidateSeconds: 60 * 5,

package/dist/api/routes/sevenelevenRoutes.js

@@ -0,0 +1,32 @@
+/**
+ * 세븐일레븐 GET API 라우트 등록
+ */
+import { withEdgeCache } from '../../utils/cache.js';
+import { handleSevenElevenCheckInventory, handleSevenElevenGetCatalogSnapshot, handleSevenElevenGetSearchPopwords, handleSevenElevenSearchStores, handleSevenElevenSearchProducts, } from '../sevenelevenHandlers.js';
+export function registerSevenElevenRoutes(app) {
+    app.get('/api/seveneleven/products', async (c) => withEdgeCache(c.req.url, {
+        ttlSeconds: 60 * 3,
+        staleWhileRevalidateSeconds: 60,
+        keyPrefix: 'seveneleven-products-v1',
+    }, () => handleSevenElevenSearchProducts(c)));
+    app.get('/api/seveneleven/stores', async (c) => withEdgeCache(c.req.url, {
+        ttlSeconds: 60 * 3,
+        staleWhileRevalidateSeconds: 60,
+        keyPrefix: 'seveneleven-stores-v1',
+    }, () => handleSevenElevenSearchStores(c)));
+    app.get('/api/seveneleven/inventory', async (c) => withEdgeCache(c.req.url, {
+        ttlSeconds: 60 * 10,
+        staleWhileRevalidateSeconds: 60,
+        keyPrefix: 'seveneleven-inventory-v1',
+    }, () => handleSevenElevenCheckInventory(c)));
+    app.get('/api/seveneleven/popwords', async (c) => withEdgeCache(c.req.url, {
+        ttlSeconds: 60 * 5,
+        staleWhileRevalidateSeconds: 60,
+        keyPrefix: 'seveneleven-popwords-v1',
+    }, () => handleSevenElevenGetSearchPopwords(c)));
+    app.get('/api/seveneleven/catalog', async (c) => withEdgeCache(c.req.url, {
+        ttlSeconds: 60 * 5,
+        staleWhileRevalidateSeconds: 60,
+        keyPrefix: 'seveneleven-catalog-v1',
+    }, () => handleSevenElevenGetCatalogSnapshot(c)));
+}