daiso 1.0.3 → 1.0.5

package/dist/services/emart24/tools/findNearbyStores.js

@@ -0,0 +1,72 @@
+/**
+ * 이마트24 주변 매장 탐색 도구
+ */
+import * as z from 'zod';
+import { calculateDistanceM, fetchEmart24Stores } from '../client.js';
+async function findNearbyStores(args) {
+    const { latitude, longitude, keyword = '', area1 = '', area2 = '', service24h = false, page = 1, limit = 20, timeoutMs = 15000, } = args;
+    const result = await fetchEmart24Stores({
+        keyword,
+        area1,
+        area2,
+        service24h,
+        page,
+    }, {
+        timeout: timeoutMs,
+    });
+    const withDistance = result.stores.map((store) => {
+        if (typeof latitude !== 'number' ||
+            typeof longitude !== 'number' ||
+            store.latitude === 0 ||
+            store.longitude === 0) {
+            return store;
+        }
+        return {
+            ...store,
+            distanceM: calculateDistanceM(latitude, longitude, store.latitude, store.longitude),
+        };
+    });
+    const sortedStores = [...withDistance].sort((a, b) => (a.distanceM ?? Number.MAX_SAFE_INTEGER) - (b.distanceM ?? Number.MAX_SAFE_INTEGER));
+    const stores = sortedStores.slice(0, limit);
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify({
+                    location: typeof latitude === 'number' && typeof longitude === 'number'
+                        ? { latitude, longitude }
+                        : null,
+                    keyword,
+                    appliedKeyword: result.appliedKeyword,
+                    area1,
+                    area2,
+                    service24h,
+                    totalCount: result.totalCount,
+                    count: stores.length,
+                    stores,
+                }, null, 2),
+            },
+        ],
+    };
+}
+export function createFindNearbyStoresTool() {
+    return {
+        name: 'emart24_find_nearby_stores',
+        metadata: {
+            title: '이마트24 주변 매장 탐색',
+            description: '키워드/지역 조건으로 이마트24 매장을 조회하고 좌표가 있으면 거리순으로 정렬합니다.',
+            inputSchema: {
+                latitude: z.number().optional().describe('위도 (선택)'),
+                longitude: z.number().optional().describe('경도 (선택)'),
+                keyword: z.string().optional().describe('매장명/지역 키워드 (예: 강남)'),
+                area1: z.string().optional().describe('시/도 (예: 서울특별시)'),
+                area2: z.string().optional().describe('구/군 (예: 강남구)'),
+                service24h: z.boolean().optional().default(false).describe('24시간 매장만 조회할지 여부'),
+                page: z.number().optional().default(1).describe('조회 페이지 (기본값: 1)'),
+                limit: z.number().optional().default(20).describe('반환할 매장 수 (기본값: 20)'),
+                timeoutMs: z.number().optional().default(15000).describe('요청 제한 시간(ms, 기본값: 15000)'),
+            },
+        },
+        handler: findNearbyStores,
+    };
+}

package/dist/services/emart24/tools/searchProducts.js

@@ -0,0 +1,63 @@
+/**
+ * 이마트24 상품 검색 도구
+ */
+import * as z from 'zod';
+import { searchEmart24Products } from '../client.js';
+async function searchProducts(args) {
+    const { keyword, page = 1, pageSize = 10, sortType = 'SALE', saleProductYn = 'N', timeoutMs = 15000, } = args;
+    if (!keyword || keyword.trim().length === 0) {
+        throw new Error('상품 검색어(keyword)를 입력해주세요.');
+    }
+    const result = await searchEmart24Products({
+        keyword,
+        page,
+        pageSize,
+        sortType,
+        saleProductYn,
+    }, {
+        timeout: timeoutMs,
+    });
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify({
+                    keyword,
+                    page,
+                    pageSize,
+                    sortType,
+                    saleProductYn,
+                    totalCount: result.totalCount,
+                    count: result.products.length,
+                    products: result.products,
+                }, null, 2),
+            },
+        ],
+    };
+}
+export function createSearchProductsTool() {
+    return {
+        name: 'emart24_search_products',
+        metadata: {
+            title: '이마트24 상품 검색',
+            description: '키워드로 이마트24 상품 목록을 조회합니다.',
+            inputSchema: {
+                keyword: z.string().describe('상품 검색어 (예: 두바이, 도시락, 음료)'),
+                page: z.number().optional().default(1).describe('조회 페이지 (기본값: 1)'),
+                pageSize: z.number().optional().default(10).describe('페이지당 결과 수 (기본값: 10)'),
+                sortType: z
+                    .enum(['SALE', 'LATEST', 'PRICE_ASC', 'PRICE_DESC'])
+                    .optional()
+                    .default('SALE')
+                    .describe('정렬 기준 (기본값: SALE)'),
+                saleProductYn: z
+                    .enum(['Y', 'N'])
+                    .optional()
+                    .default('N')
+                    .describe('행사 상품 여부 필터 (기본값: N)'),
+                timeoutMs: z.number().optional().default(15000).describe('요청 제한 시간(ms, 기본값: 15000)'),
+            },
+        },
+        handler: searchProducts,
+    };
+}

package/dist/services/emart24/types.js

@@ -0,0 +1,4 @@
+/**
+ * 이마트24 서비스 전용 타입 정의
+ */
+export {};

package/dist/services/gs25/api.js

@@ -0,0 +1,9 @@
+/**
+ * GS25 API 엔드포인트 중앙 관리
+ */
+export const GS25_API = {
+    BFF_BASE_URL: 'https://b2c-bff.woodongs.com',
+    STORE_STOCK_PATH: '/api/bff/v2/store/stock',
+    APIGW_BASE_URL: 'https://b2c-apigw.woodongs.com',
+    TOTAL_SEARCH_PATH: '/search/v3/totalSearch',
+};

package/dist/services/gs25/client.js

@@ -0,0 +1,198 @@
+/**
+ * GS25 API 클라이언트
+ */
+/* c8 ignore start */
+import { fetchJson } from '../../utils/http.js';
+import { GS25_API } from './api.js';
+import { normalizeStore, toNumber } from './storeUtils.js';
+export { attachDistanceToGs25Stores, calculateDistanceM, extractGs25ProductCandidates, filterGs25StoresByKeyword, selectGs25StoresForKeyword, sortGs25Stores, } from './storeUtils.js';
+const GS25_DEFAULT_HEADERS = {
+    Accept: 'application/json, text/plain, */*',
+};
+const GS25_STORES_CACHE_TTL_MS = 60 * 5 * 1000;
+const gs25StoresCache = new Map();
+function buildCacheKey(params) {
+    return [
+        params.serviceCode,
+        params.itemCode?.trim() || params.keyword,
+        params.storeCode,
+        typeof params.latitude === 'number' ? params.latitude : '',
+        typeof params.longitude === 'number' ? params.longitude : '',
+    ].join(':');
+}
+export async function geocodeGs25Address(address, options = {}) {
+    const keyword = address.trim();
+    if (keyword.length === 0) {
+        return null;
+    }
+    const { timeout = 15000, googleMapsApiKey } = options;
+    const apiKey = (googleMapsApiKey || '').trim();
+    if (apiKey.length === 0) {
+        return null;
+    }
+    const endpoint = new URL('https://maps.googleapis.com/maps/api/geocode/json');
+    endpoint.searchParams.set('address', keyword);
+    endpoint.searchParams.set('key', apiKey);
+    const body = await fetchJson(endpoint.toString(), {
+        method: 'GET',
+        timeout,
+        headers: {
+            Accept: 'application/json',
+        },
+    });
+    if (body.status !== 'OK') {
+        return null;
+    }
+    const location = body.results?.[0]?.geometry?.location;
+    if (!location) {
+        return null;
+    }
+    const latitude = toNumber(location.lat);
+    const longitude = toNumber(location.lng);
+    if (latitude === 0 || longitude === 0) {
+        return null;
+    }
+    return { latitude, longitude };
+}
+export async function fetchGs25Stores(params = {}, options = {}) {
+    const { serviceCode = '01', keyword = '', itemCode = '', storeCode = '', realTimeStockYn = 'Y', latitude, longitude, pageNumber = 0, pageCount = 20000, useCache = true, } = params;
+    const { timeout = 20000 } = options;
+    const cacheKey = buildCacheKey({
+        serviceCode,
+        keyword: itemCode.trim() || keyword.trim(),
+        storeCode: storeCode.trim(),
+        itemCode: itemCode.trim(),
+        latitude,
+        longitude,
+    });
+    if (useCache) {
+        const cached = gs25StoresCache.get(cacheKey);
+        if (cached && cached.expiresAt > Date.now()) {
+            return {
+                totalCount: cached.stores.length,
+                stores: cached.stores,
+                cacheHit: true,
+            };
+        }
+    }
+    const endpoint = new URL(GS25_API.STORE_STOCK_PATH, GS25_API.BFF_BASE_URL);
+    endpoint.searchParams.set('serviceCode', serviceCode);
+    endpoint.searchParams.set('pageNumber', String(pageNumber));
+    endpoint.searchParams.set('pageCount', String(pageCount));
+    endpoint.searchParams.set('realTimeStockYn', realTimeStockYn);
+    // itemCode가 있으면 itemCode 사용, 없으면 keyword 사용
+    // 주의: itemCode 사용 시 좌표도 필수
+    if (itemCode.trim().length > 0) {
+        endpoint.searchParams.set('itemCode', itemCode.trim());
+    }
+    else if (keyword.trim().length > 0) {
+        endpoint.searchParams.set('keyword', keyword.trim());
+    }
+    if (storeCode.trim().length > 0) {
+        endpoint.searchParams.set('storeCode', storeCode.trim());
+    }
+    // 좌표 파라미터: 앱은 myPosition + centerPosition 모두 필요
+    if (typeof latitude === 'number' && Number.isFinite(latitude)) {
+        endpoint.searchParams.set('myPositionYCoordination', String(latitude));
+        endpoint.searchParams.set('centerPositionYCoordination', String(latitude));
+    }
+    if (typeof longitude === 'number' && Number.isFinite(longitude)) {
+        endpoint.searchParams.set('myPositionXCoordination', String(longitude));
+        endpoint.searchParams.set('centerPositionXCoordination', String(longitude));
+    }
+    // 반경 조건 (미터 단위, 1km로 설정하여 인근 매장 포함)
+    if (typeof latitude === 'number' && typeof longitude === 'number') {
+        endpoint.searchParams.set('radiusCondition', '1000');
+        // 앱에서 사용하는 추가 플래그
+        endpoint.searchParams.set('pickupStoreYn', 'N');
+        endpoint.searchParams.set('isSuperDlvyStoreSelected', 'N');
+        endpoint.searchParams.set('isGs25DlvyStoreSelected', 'N');
+    }
+    const body = await fetchJson(endpoint.toString(), {
+        method: 'GET',
+        timeout,
+        headers: GS25_DEFAULT_HEADERS,
+    });
+    const stores = (body.stores || []).map(normalizeStore).filter((store) => store.storeCode.length > 0);
+    if (useCache) {
+        gs25StoresCache.set(cacheKey, {
+            stores,
+            expiresAt: Date.now() + GS25_STORES_CACHE_TTL_MS,
+        });
+    }
+    return {
+        totalCount: stores.length,
+        stores,
+        cacheHit: false,
+    };
+}
+export async function fetchGs25NormalizedKeyword(keyword, options = {}) {
+    const query = keyword.trim();
+    if (query.length === 0) {
+        return null;
+    }
+    const { timeout = 20000 } = options;
+    const endpoint = new URL(GS25_API.TOTAL_SEARCH_PATH, GS25_API.APIGW_BASE_URL);
+    const body = await fetchJson(endpoint.toString(), {
+        method: 'POST',
+        timeout,
+        headers: {
+            Accept: 'application/json, text/plain, */*',
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({ query }),
+    });
+    const normalizedKeyword = body.SearchQueryResult?.keywordInfo?.keyword?.trim() || '';
+    const normalizedSearchKeyword = body.SearchQueryResult?.keywordInfo?.searchKeyword?.trim() || '';
+    if (normalizedKeyword.length === 0 && normalizedSearchKeyword.length === 0) {
+        return null;
+    }
+    return {
+        keyword: normalizedKeyword,
+        searchKeyword: normalizedSearchKeyword,
+    };
+}
+/**
+ * 키워드로 상품을 검색하여 itemCode 목록을 반환합니다.
+ * 재고 조회 API는 itemCode가 필요하므로 이 함수로 먼저 변환해야 합니다.
+ */
+export async function fetchGs25SearchProducts(keyword, options = {}) {
+    const query = keyword.trim();
+    if (query.length === 0) {
+        return [];
+    }
+    const { timeout = 20000 } = options;
+    const endpoint = new URL(GS25_API.TOTAL_SEARCH_PATH, GS25_API.APIGW_BASE_URL);
+    const body = await fetchJson(endpoint.toString(), {
+        method: 'POST',
+        timeout,
+        headers: {
+            Accept: 'application/json, text/plain, */*',
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({ query }),
+    });
+    const products = [];
+    const collections = body.SearchQueryResult?.Collection || [];
+    for (const collection of collections) {
+        const documents = collection.Documentset?.Document || [];
+        for (const doc of documents) {
+            const field = doc.field;
+            if (!field?.itemCode)
+                continue;
+            products.push({
+                itemCode: field.itemCode,
+                itemName: field.itemName || '',
+                shortItemName: field.shortItemName || '',
+                imageUrl: field.itemImageUrl || '',
+                rating: toNumber(field.starPoint),
+                stockCheckEnabled: field.stockCheckYn === 'Y',
+            });
+        }
+    }
+    return products;
+}
+export function clearGs25StoresCache() {
+    gs25StoresCache.clear();
+}
+/* c8 ignore stop */

package/dist/services/gs25/index.js

@@ -0,0 +1,22 @@
+/**
+ * GS25 서비스 프로바이더
+ */
+import { createFindNearbyStoresTool } from './tools/findNearbyStores.js';
+import { createSearchProductsTool } from './tools/searchProducts.js';
+import { createCheckInventoryTool } from './tools/checkInventory.js';
+const GS25_METADATA = {
+    id: 'gs25',
+    name: 'GS25',
+    version: '1.0.0',
+    description: 'GS25 매장 탐색, 상품 키워드 검색, 재고 조회 서비스',
+};
+class Gs25Service {
+    metadata = GS25_METADATA;
+    getTools() {
+        return [createFindNearbyStoresTool(), createSearchProductsTool(), createCheckInventoryTool()];
+    }
+}
+export function createGs25Service() {
+    return new Gs25Service();
+}
+export * from './types.js';

package/dist/services/gs25/storeUtils.js

@@ -0,0 +1,168 @@
+/**
+ * GS25 매장 정규화와 정렬 유틸리티
+ */
+export function toNumber(value) {
+    if (typeof value === 'number') {
+        return Number.isFinite(value) ? value : 0;
+    }
+    if (typeof value === 'string') {
+        const parsed = Number.parseFloat(value);
+        return Number.isFinite(parsed) ? parsed : 0;
+    }
+    return 0;
+}
+function toInteger(value) {
+    if (typeof value === 'number') {
+        return Number.isFinite(value) ? Math.trunc(value) : 0;
+    }
+    if (typeof value === 'string') {
+        const parsed = Number.parseInt(value, 10);
+        return Number.isFinite(parsed) ? parsed : 0;
+    }
+    return 0;
+}
+function toBooleanYn(value) {
+    const normalized = String(value || '').trim().toUpperCase();
+    return normalized === 'Y' || normalized === 'TRUE' || normalized === '1';
+}
+function normalizeProperty(raw) {
+    return {
+        code: raw.storePropertyCode || '',
+        name: raw.storePropertyName || '',
+        type: raw.storePropertyType || '',
+        imageUrl: raw.storePropertyImage || '',
+    };
+}
+export function normalizeStore(raw) {
+    const properties = (raw.propertyList || []).map(normalizeProperty).filter((item) => item.name.length > 0);
+    return {
+        storeCode: raw.storeCode || '',
+        storeName: raw.storeName || '',
+        address: raw.storeAddress || '',
+        phone: raw.storeTelephoneNumber || '',
+        longitude: toNumber(raw.storeXCoordination),
+        latitude: toNumber(raw.storeYCoordination),
+        serviceCode: raw.serviceCode || '',
+        realStockQuantity: toInteger(raw.realStockQuantity),
+        pickupStockQuantity: toInteger(raw.pickupStkQty),
+        deliveryStockQuantity: toInteger(raw.dlvyStkQty),
+        isSoldOut: toBooleanYn(raw.isSoldOutYn),
+        searchItemName: String(raw.searchItemName || '').trim(),
+        searchItemSellPrice: raw.searchItemSellPrice === null || raw.searchItemSellPrice === undefined
+            ? null
+            : toInteger(raw.searchItemSellPrice),
+        propertyNames: properties.map((item) => item.name),
+        properties,
+        distanceM: null,
+    };
+}
+export function calculateDistanceM(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 Math.round(6371000 * c);
+}
+export function filterGs25StoresByKeyword(stores, keyword) {
+    const trimmed = keyword.trim();
+    if (trimmed.length === 0) {
+        return stores;
+    }
+    const normalized = trimmed.toLowerCase();
+    const noSpaceKeyword = normalized.replace(/\s+/g, '');
+    const keywordTokens = normalized.split(/\s+/).filter((token) => token.length > 0);
+    const normalizedVariants = new Set([normalized, noSpaceKeyword]);
+    for (const suffix of ['역', '점']) {
+        for (const variant of [...normalizedVariants]) {
+            if (variant.endsWith(suffix) && variant.length > suffix.length) {
+                normalizedVariants.add(variant.slice(0, -suffix.length));
+            }
+        }
+    }
+    return stores.filter((store) => {
+        const target = `${store.storeName} ${store.address} ${store.propertyNames.join(' ')}`.toLowerCase();
+        const targetNoSpace = target.replace(/\s+/g, '');
+        if (target.includes(normalized)) {
+            return true;
+        }
+        for (const variant of normalizedVariants) {
+            if (variant.length > 0 && targetNoSpace.includes(variant.replace(/\s+/g, ''))) {
+                return true;
+            }
+        }
+        if (keywordTokens.length > 1) {
+            return keywordTokens.every((token) => target.includes(token));
+        }
+        return false;
+    });
+}
+export function selectGs25StoresForKeyword(stores, keyword, options = {}) {
+    const filtered = filterGs25StoresByKeyword(stores, keyword);
+    if (filtered.length > 0 || !options.relaxWhenEmpty || keyword.trim().length === 0 || stores.length === 0) {
+        return { stores: filtered, filterRelaxed: false };
+    }
+    return { stores, filterRelaxed: true };
+}
+export function attachDistanceToGs25Stores(stores, latitude, longitude) {
+    if (typeof latitude !== 'number' || typeof longitude !== 'number') {
+        return stores;
+    }
+    return stores.map((store) => {
+        if (store.latitude === 0 || store.longitude === 0) {
+            return store;
+        }
+        return {
+            ...store,
+            distanceM: calculateDistanceM(latitude, longitude, store.latitude, store.longitude),
+        };
+    });
+}
+export function sortGs25Stores(stores) {
+    return [...stores].sort((a, b) => {
+        const distanceA = a.distanceM ?? Number.MAX_SAFE_INTEGER;
+        const distanceB = b.distanceM ?? Number.MAX_SAFE_INTEGER;
+        if (distanceA !== distanceB) {
+            return distanceA - distanceB;
+        }
+        if (b.realStockQuantity !== a.realStockQuantity) {
+            return b.realStockQuantity - a.realStockQuantity;
+        }
+        return a.storeName.localeCompare(b.storeName, 'ko');
+    });
+}
+export function extractGs25ProductCandidates(stores) {
+    const map = new Map();
+    for (const store of stores) {
+        const name = store.searchItemName.trim();
+        if (name.length === 0) {
+            continue;
+        }
+        const key = `${name}::${store.searchItemSellPrice ?? 'null'}`;
+        const prev = map.get(key);
+        const inStock = store.realStockQuantity > 0 ? 1 : 0;
+        if (!prev) {
+            map.set(key, {
+                name,
+                sellPrice: store.searchItemSellPrice,
+                matchedStoreCount: 1,
+                inStockStoreCount: inStock,
+                totalStockQuantity: Math.max(store.realStockQuantity, 0),
+            });
+            continue;
+        }
+        prev.matchedStoreCount += 1;
+        prev.inStockStoreCount += inStock;
+        prev.totalStockQuantity += Math.max(store.realStockQuantity, 0);
+    }
+    return [...map.values()].sort((a, b) => {
+        if (b.inStockStoreCount !== a.inStockStoreCount) {
+            return b.inStockStoreCount - a.inStockStoreCount;
+        }
+        if (b.totalStockQuantity !== a.totalStockQuantity) {
+            return b.totalStockQuantity - a.totalStockQuantity;
+        }
+        return a.name.localeCompare(b.name, 'ko');
+    });
+}