daiso 1.0.0

package/dist/api/cgvHandlers.js

@@ -0,0 +1,97 @@
+/**
+ * CGV GET API 핸들러
+ */
+import { fetchCgvMovies, fetchCgvTheaters, fetchCgvTimetable, toYyyymmdd } from '../services/cgv/client.js';
+import { filterAndSortTimetable } from '../services/cgv/timetable.js';
+import { errorResponse, successResponse } from './response.js';
+/**
+ * CGV 극장 목록 조회 API 핸들러
+ * GET /api/cgv/theaters?playDate={YYYYMMDD}&regionCode={지역코드}
+ */
+export async function handleCgvFindTheaters(c) {
+    const playDate = c.req.query('playDate') || toYyyymmdd();
+    const regionCode = c.req.query('regionCode') || undefined;
+    const limit = parseInt(c.req.query('limit') || '30');
+    const timeoutMs = parseInt(c.req.query('timeoutMs') || '15000');
+    try {
+        const theaters = await fetchCgvTheaters({
+            playDate,
+            regionCode,
+            timeout: timeoutMs,
+            zyteApiKey: c.env?.ZYTE_API_KEY,
+        });
+        const sliced = theaters.slice(0, limit);
+        return successResponse(c, {
+            playDate,
+            filters: {
+                regionCode: regionCode || null,
+            },
+            theaters: sliced,
+        }, { total: sliced.length, pageSize: limit });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : '알 수 없는 오류가 발생했습니다.';
+        return errorResponse(c, 'CGV_THEATER_SEARCH_FAILED', message, 500);
+    }
+}
+/**
+ * CGV 영화 목록 조회 API 핸들러
+ * GET /api/cgv/movies?playDate={YYYYMMDD}&theaterCode={극장코드}
+ */
+export async function handleCgvSearchMovies(c) {
+    const playDate = c.req.query('playDate') || toYyyymmdd();
+    const theaterCode = c.req.query('theaterCode') || undefined;
+    const timeoutMs = parseInt(c.req.query('timeoutMs') || '15000');
+    try {
+        const movies = await fetchCgvMovies({
+            playDate,
+            theaterCode,
+            timeout: timeoutMs,
+            zyteApiKey: c.env?.ZYTE_API_KEY,
+        });
+        return successResponse(c, {
+            playDate,
+            filters: {
+                theaterCode: theaterCode || null,
+            },
+            movies,
+        }, { total: movies.length });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : '알 수 없는 오류가 발생했습니다.';
+        return errorResponse(c, 'CGV_MOVIE_SEARCH_FAILED', message, 500);
+    }
+}
+/**
+ * CGV 시간표 조회 API 핸들러
+ * GET /api/cgv/timetable?playDate={YYYYMMDD}&theaterCode={극장코드}&movieCode={영화코드}
+ */
+export async function handleCgvGetTimetable(c) {
+    const playDate = c.req.query('playDate') || toYyyymmdd();
+    const theaterCode = c.req.query('theaterCode') || undefined;
+    const movieCode = c.req.query('movieCode') || undefined;
+    const limit = parseInt(c.req.query('limit') || '50');
+    const timeoutMs = parseInt(c.req.query('timeoutMs') || '15000');
+    try {
+        const timetable = await fetchCgvTimetable({
+            playDate,
+            theaterCode,
+            movieCode,
+            timeout: timeoutMs,
+            zyteApiKey: c.env?.ZYTE_API_KEY,
+        });
+        const filtered = filterAndSortTimetable(timetable, { theaterCode, movieCode, limit });
+        return successResponse(c, {
+            playDate,
+            filters: {
+                theaterCode: theaterCode || null,
+                movieCode: movieCode || null,
+            },
+            timetable: filtered,
+        }, { total: filtered.length, pageSize: limit });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : '알 수 없는 오류가 발생했습니다.';
+        return errorResponse(c, 'CGV_TIMETABLE_FETCH_FAILED', message, 500);
+    }
+}

package/dist/api/handlers.js

@@ -0,0 +1,208 @@
+/**
+ * GET API 핸들러
+ *
+ * MCP 미지원 서비스를 위한 GET 기반 API 핸들러입니다.
+ * 기존 도구의 핵심 함수들을 재사용합니다.
+ */
+import { fetchProducts } from '../services/daiso/tools/searchProducts.js';
+import { fetchStores } from '../services/daiso/tools/findStores.js';
+import { fetchOnlineStock, fetchStoreInventory, } from '../services/daiso/tools/checkInventory.js';
+import { fetchProductById } from '../services/daiso/tools/getPriceInfo.js';
+import { getImageUrl } from '../services/daiso/api.js';
+import { fetchOliveyoungProducts, fetchOliveyoungStores, } from '../services/oliveyoung/client.js';
+import { errorResponse, successResponse } from './response.js';
+/**
+ * 제품 검색 API 핸들러
+ * GET /api/daiso/products?q={검색어}&page={페이지}&pageSize={개수}
+ */
+export async function handleSearchProducts(c) {
+    const query = c.req.query('q');
+    const page = parseInt(c.req.query('page') || '1');
+    const pageSize = parseInt(c.req.query('pageSize') || '30');
+    if (!query || query.trim().length === 0) {
+        return errorResponse(c, 'MISSING_QUERY', '검색어(q)를 입력해주세요.');
+    }
+    try {
+        const { products, totalCount } = await fetchProducts(query, page, pageSize);
+        return successResponse(c, { products }, { total: totalCount, page, pageSize });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : '알 수 없는 오류가 발생했습니다.';
+        return errorResponse(c, 'SEARCH_FAILED', message, 500);
+    }
+}
+/**
+ * 제품 상세 정보 API 핸들러
+ * GET /api/daiso/products/:id
+ */
+export async function handleGetProduct(c) {
+    const productId = c.req.param('id');
+    if (!productId) {
+        return errorResponse(c, 'MISSING_ID', '제품 ID가 필요합니다.');
+    }
+    try {
+        const product = await fetchProductById(productId);
+        if (!product) {
+            return errorResponse(c, 'NOT_FOUND', '제품을 찾을 수 없습니다.', 404);
+        }
+        const result = {
+            id: product.PD_NO,
+            name: product.PDNM || product.EXH_PD_NM,
+            price: parseInt(product.PD_PRC) || 0,
+            currency: 'KRW',
+            imageUrl: getImageUrl(product.ATCH_FILE_URL),
+            brand: product.BRND_NM || undefined,
+            soldOut: product.SOLD_OUT_YN === 'Y',
+            isNew: product.NEW_PD_YN === 'Y',
+        };
+        return successResponse(c, result);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : '알 수 없는 오류가 발생했습니다.';
+        return errorResponse(c, 'FETCH_FAILED', message, 500);
+    }
+}
+/**
+ * 매장 검색 API 핸들러
+ * GET /api/daiso/stores?keyword={키워드}&sido={시도}&gugun={구군}&dong={동}&limit={개수}
+ */
+export async function handleFindStores(c) {
+    const keyword = c.req.query('keyword');
+    const sido = c.req.query('sido');
+    const gugun = c.req.query('gugun');
+    const dong = c.req.query('dong');
+    const limit = parseInt(c.req.query('limit') || '50');
+    if (!keyword && !sido) {
+        return errorResponse(c, 'MISSING_PARAMS', '검색어(keyword) 또는 지역(sido)을 입력해주세요.');
+    }
+    try {
+        const stores = await fetchStores(keyword, sido, gugun, dong);
+        const limitedStores = stores.slice(0, limit);
+        return successResponse(c, { stores: limitedStores }, { total: stores.length });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : '알 수 없는 오류가 발생했습니다.';
+        return errorResponse(c, 'SEARCH_FAILED', message, 500);
+    }
+}
+/**
+ * 재고 확인 API 핸들러
+ * GET /api/daiso/inventory?productId={제품ID}&lat={위도}&lng={경도}&keyword={매장검색어}
+ */
+export async function handleCheckInventory(c) {
+    const productId = c.req.query('productId');
+    const lat = parseFloat(c.req.query('lat') || '37.5665');
+    const lng = parseFloat(c.req.query('lng') || '126.978');
+    const keyword = c.req.query('keyword') || '';
+    const page = parseInt(c.req.query('page') || '1');
+    const pageSize = parseInt(c.req.query('pageSize') || '30');
+    if (!productId) {
+        return errorResponse(c, 'MISSING_PRODUCT_ID', '제품 ID(productId)를 입력해주세요.');
+    }
+    try {
+        const [onlineStock, storeResult] = await Promise.all([
+            fetchOnlineStock(productId),
+            fetchStoreInventory(productId, lat, lng, page, pageSize, keyword),
+        ]);
+        const inStockStores = storeResult.stores.filter((s) => s.quantity > 0);
+        const result = {
+            productId,
+            location: { latitude: lat, longitude: lng },
+            onlineStock,
+            storeInventory: {
+                totalStores: storeResult.totalCount,
+                inStockCount: inStockStores.length,
+                stores: storeResult.stores,
+            },
+        };
+        return successResponse(c, result, { total: storeResult.totalCount, page, pageSize });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : '알 수 없는 오류가 발생했습니다.';
+        return errorResponse(c, 'INVENTORY_CHECK_FAILED', message, 500);
+    }
+}
+/**
+ * 올리브영 매장 검색 API 핸들러
+ * GET /api/oliveyoung/stores?keyword={키워드}&lat={위도}&lng={경도}
+ */
+export async function handleOliveyoungFindStores(c) {
+    const keyword = c.req.query('keyword') || '';
+    const lat = parseFloat(c.req.query('lat') || '37.5665');
+    const lng = parseFloat(c.req.query('lng') || '126.978');
+    const pageIdx = parseInt(c.req.query('pageIdx') || '1');
+    const limit = parseInt(c.req.query('limit') || '20');
+    try {
+        const result = await fetchOliveyoungStores({
+            latitude: lat,
+            longitude: lng,
+            pageIdx,
+            searchWords: keyword,
+        }, {
+            apiKey: c.env.ZYTE_API_KEY,
+        });
+        return successResponse(c, {
+            stores: result.stores.slice(0, limit),
+        }, { total: result.totalCount, page: pageIdx, pageSize: limit });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : '알 수 없는 오류가 발생했습니다.';
+        return errorResponse(c, 'OLIVEYOUNG_STORE_SEARCH_FAILED', message, 500);
+    }
+}
+/**
+ * 올리브영 재고 확인 API 핸들러
+ * GET /api/oliveyoung/inventory?keyword={검색어}&lat={위도}&lng={경도}
+ */
+export async function handleOliveyoungCheckInventory(c) {
+    const keyword = c.req.query('keyword');
+    const lat = parseFloat(c.req.query('lat') || '37.5665');
+    const lng = parseFloat(c.req.query('lng') || '126.978');
+    const storeKeyword = c.req.query('storeKeyword') || '';
+    const page = parseInt(c.req.query('page') || '1');
+    const size = parseInt(c.req.query('size') || '20');
+    const sort = c.req.query('sort') || '01';
+    const includeSoldOut = c.req.query('includeSoldOut') === 'true';
+    const storeLimit = parseInt(c.req.query('storeLimit') || '10');
+    if (!keyword || keyword.trim().length === 0) {
+        return errorResponse(c, 'MISSING_QUERY', '검색어(keyword)를 입력해주세요.');
+    }
+    try {
+        const [storeResult, productResult] = await Promise.all([
+            fetchOliveyoungStores({
+                latitude: lat,
+                longitude: lng,
+                pageIdx: 1,
+                searchWords: storeKeyword,
+            }, {
+                apiKey: c.env.ZYTE_API_KEY,
+            }),
+            fetchOliveyoungProducts({
+                keyword,
+                page,
+                size,
+                sort,
+                includeSoldOut,
+            }, {
+                apiKey: c.env.ZYTE_API_KEY,
+            }),
+        ]);
+        return successResponse(c, {
+            keyword,
+            location: { latitude: lat, longitude: lng },
+            nearbyStores: {
+                totalCount: storeResult.totalCount,
+                stores: storeResult.stores.slice(0, storeLimit),
+            },
+            inventory: {
+                totalCount: productResult.totalCount,
+                nextPage: productResult.nextPage,
+                products: productResult.products,
+            },
+        }, { total: productResult.totalCount, page, pageSize: size });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : '알 수 없는 오류가 발생했습니다.';
+        return errorResponse(c, 'OLIVEYOUNG_INVENTORY_CHECK_FAILED', message, 500);
+    }
+}

package/dist/api/megaboxHandlers.js

@@ -0,0 +1,145 @@
+/**
+ * 메가박스 GET API 핸들러
+ */
+import { fetchMegaboxBookingList, fetchMegaboxTheaterInfo, toYyyymmdd, } from '../services/megabox/client.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;
+}
+/**
+ * 메가박스 주변 지점 조회 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 playDate = c.req.query('playDate') || toYyyymmdd();
+    const areaCode = c.req.query('areaCode') || '11';
+    const limit = parseInt(c.req.query('limit') || '10');
+    const timeoutMs = parseInt(c.req.query('timeoutMs') || '15000');
+    try {
+        const { theaters } = await fetchMegaboxBookingList({
+            playDate,
+            areaCode,
+            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 });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : '알 수 없는 오류가 발생했습니다.';
+        return errorResponse(c, 'MEGABOX_THEATER_SEARCH_FAILED', message, 500);
+    }
+}
+/**
+ * 메가박스 영화/회차 목록 조회 API 핸들러
+ * GET /api/megabox/movies?playDate={YYYYMMDD}&theaterId={지점ID}&movieId={영화ID}
+ */
+export async function handleMegaboxListNowShowing(c) {
+    const playDate = c.req.query('playDate') || toYyyymmdd();
+    const theaterId = c.req.query('theaterId') || undefined;
+    const movieId = c.req.query('movieId') || undefined;
+    const areaCode = c.req.query('areaCode') || '11';
+    const timeoutMs = parseInt(c.req.query('timeoutMs') || '15000');
+    try {
+        const result = await fetchMegaboxBookingList({
+            playDate,
+            theaterId,
+            movieId,
+            areaCode,
+            timeout: timeoutMs,
+        });
+        return successResponse(c, {
+            playDate,
+            filters: {
+                theaterId: theaterId || null,
+                movieId: movieId || null,
+                areaCode,
+            },
+            theaters: result.theaters,
+            movies: result.movies,
+            showtimes: result.showtimes,
+        }, { total: result.showtimes.length });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : '알 수 없는 오류가 발생했습니다.';
+        return errorResponse(c, 'MEGABOX_MOVIE_LIST_FAILED', message, 500);
+    }
+}
+/**
+ * 메가박스 잔여 좌석 조회 API 핸들러
+ * GET /api/megabox/seats?playDate={YYYYMMDD}&theaterId={지점ID}&movieId={영화ID}
+ */
+export async function handleMegaboxGetRemainingSeats(c) {
+    const playDate = c.req.query('playDate') || toYyyymmdd();
+    const theaterId = c.req.query('theaterId') || undefined;
+    const movieId = c.req.query('movieId') || undefined;
+    const areaCode = c.req.query('areaCode') || '11';
+    const limit = parseInt(c.req.query('limit') || '50');
+    const timeoutMs = parseInt(c.req.query('timeoutMs') || '15000');
+    try {
+        const { showtimes } = await fetchMegaboxBookingList({
+            playDate,
+            theaterId,
+            movieId,
+            areaCode,
+            timeout: timeoutMs,
+        });
+        const seats = showtimes
+            .filter((item) => (theaterId ? item.theaterId === theaterId : true))
+            .filter((item) => (movieId ? item.movieId === movieId : true))
+            .sort((a, b) => {
+            if (a.startTime === b.startTime) {
+                return a.theaterName.localeCompare(b.theaterName);
+            }
+            return a.startTime.localeCompare(b.startTime);
+        })
+            .slice(0, limit);
+        return successResponse(c, {
+            playDate,
+            filters: {
+                theaterId: theaterId || null,
+                movieId: movieId || null,
+                areaCode,
+            },
+            seats,
+        }, { total: seats.length, pageSize: limit });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : '알 수 없는 오류가 발생했습니다.';
+        return errorResponse(c, 'MEGABOX_SEAT_LIST_FAILED', message, 500);
+    }
+}

package/dist/api/response.js

@@ -0,0 +1,22 @@
+/**
+ * API 공통 응답 유틸리티
+ */
+/**
+ * 성공 응답 생성
+ */
+export function successResponse(c, data, meta) {
+    return c.json({
+        success: true,
+        data,
+        meta,
+    });
+}
+/**
+ * 에러 응답 생성
+ */
+export function errorResponse(c, code, message, status = 400) {
+    return c.json({
+        success: false,
+        error: { code, message },
+    }, status);
+}

package/dist/api/routes/cgvRoutes.js

@@ -0,0 +1,22 @@
+/**
+ * CGV GET API 라우트 등록
+ */
+import { withEdgeCache } from '../../utils/cache.js';
+import { handleCgvFindTheaters, handleCgvGetTimetable, handleCgvSearchMovies } from '../cgvHandlers.js';
+export function registerCgvRoutes(app) {
+    app.get('/api/cgv/theaters', async (c) => withEdgeCache(c.req.url, {
+        ttlSeconds: 60 * 60 * 24,
+        staleWhileRevalidateSeconds: 60 * 5,
+        keyPrefix: 'cgv-theaters-v1',
+    }, () => handleCgvFindTheaters(c)));
+    app.get('/api/cgv/movies', async (c) => withEdgeCache(c.req.url, {
+        ttlSeconds: 60 * 10,
+        staleWhileRevalidateSeconds: 60,
+        keyPrefix: 'cgv-movies-v1',
+    }, () => handleCgvSearchMovies(c)));
+    app.get('/api/cgv/timetable', async (c) => withEdgeCache(c.req.url, {
+        ttlSeconds: 60 * 3,
+        staleWhileRevalidateSeconds: 30,
+        keyPrefix: 'cgv-timetable-v1',
+    }, () => handleCgvGetTimetable(c)));
+}

package/dist/api/routes/daisoRoutes.js

@@ -0,0 +1,27 @@
+/**
+ * 다이소 GET API 라우트 등록
+ */
+import { withEdgeCache } from '../../utils/cache.js';
+import { handleSearchProducts, handleGetProduct, handleFindStores, handleCheckInventory, } from '../handlers.js';
+export function registerDaisoRoutes(app) {
+    app.get('/api/daiso/products', async (c) => withEdgeCache(c.req.url, {
+        ttlSeconds: 60 * 30,
+        staleWhileRevalidateSeconds: 60 * 3,
+        keyPrefix: 'daiso-products-v1',
+    }, () => handleSearchProducts(c)));
+    app.get('/api/daiso/products/:id', async (c) => withEdgeCache(c.req.url, {
+        ttlSeconds: 60 * 60,
+        staleWhileRevalidateSeconds: 60 * 5,
+        keyPrefix: 'daiso-product-detail-v1',
+    }, () => handleGetProduct(c)));
+    app.get('/api/daiso/stores', async (c) => withEdgeCache(c.req.url, {
+        ttlSeconds: 60 * 60 * 24,
+        staleWhileRevalidateSeconds: 60 * 5,
+        keyPrefix: 'daiso-stores-v1',
+    }, () => handleFindStores(c)));
+    app.get('/api/daiso/inventory', async (c) => withEdgeCache(c.req.url, {
+        ttlSeconds: 60 * 10,
+        staleWhileRevalidateSeconds: 60,
+        keyPrefix: 'daiso-inventory-v1',
+    }, () => handleCheckInventory(c)));
+}

package/dist/api/routes/megaboxRoutes.js

@@ -0,0 +1,22 @@
+/**
+ * 메가박스 GET API 라우트 등록
+ */
+import { withEdgeCache } from '../../utils/cache.js';
+import { handleMegaboxFindNearbyTheaters, handleMegaboxListNowShowing, handleMegaboxGetRemainingSeats, } from '../megaboxHandlers.js';
+export function registerMegaboxRoutes(app) {
+    app.get('/api/megabox/theaters', async (c) => withEdgeCache(c.req.url, {
+        ttlSeconds: 60 * 60 * 24,
+        staleWhileRevalidateSeconds: 60 * 5,
+        keyPrefix: 'megabox-theaters-v1',
+    }, () => handleMegaboxFindNearbyTheaters(c)));
+    app.get('/api/megabox/movies', async (c) => withEdgeCache(c.req.url, {
+        ttlSeconds: 60 * 10,
+        staleWhileRevalidateSeconds: 60,
+        keyPrefix: 'megabox-movies-v1',
+    }, () => handleMegaboxListNowShowing(c)));
+    app.get('/api/megabox/seats', async (c) => withEdgeCache(c.req.url, {
+        ttlSeconds: 60 * 3,
+        staleWhileRevalidateSeconds: 30,
+        keyPrefix: 'megabox-seats-v1',
+    }, () => handleMegaboxGetRemainingSeats(c)));
+}

package/dist/api/routes/oliveyoungRoutes.js

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