daiso 1.0.5 → 1.0.7

package/dist/services/lottemart/zetta.js

@@ -71,7 +71,7 @@ function clampZettaPageLimit(pageLimit) {
     }
     return pageLimit;
 }
-async function fetchZettaLotteMartProducts(resolvedStore, keyword, pageLimit, timeout) {
+export async function fetchZettaLotteMartProducts(resolvedStore, keyword, pageLimit, timeout) {
     const products = [];
     let nextPageToken;
     let fetchedPages = 0;

package/dist/services/oliveyoung/client.js

@@ -6,6 +6,12 @@
 import { OLIVEYOUNG_API } from './api.js';
 import { decodeBase64, requestByZyte } from '../../utils/zyte.js';
 const OLIVEYOUNG_IMAGE_HOST = 'https://image.oliveyoung.co.kr';
+const OLIVEYOUNG_PRODUCT_ID_CACHE_TTL_MS = 10 * 60 * 1000;
+const OLIVEYOUNG_PRODUCT_SEARCH_STALE_CACHE_TTL_MS = 30 * 60 * 1000;
+const oliveyoungProductIdCache = new Map();
+const oliveyoungProductSearchCache = new Map();
+const oliveyoungStoreSearchCache = new Map();
+const oliveyoungStockStoresCache = new Map();
 const OLIVEYOUNG_IMAGE_PATH_PREFIX = '/uploads/images/goods';
 function resolveOliveyoungInStock(o2oStockFlag, o2oRemainQuantity) {
     return o2oStockFlag || o2oRemainQuantity > 0;
@@ -60,6 +66,50 @@ function resolveOliveyoungStoreStock(rawStore) {
         openYn: Boolean(rawStore?.openYn),
     };
 }
+function createOliveyoungProductSearchCacheKey(params) {
+    return JSON.stringify([params.keyword, params.page, params.size, params.sort, params.includeSoldOut]);
+}
+function createOliveyoungStoreSearchCacheKey(params) {
+    return JSON.stringify([params.latitude, params.longitude, params.pageIdx, params.searchWords]);
+}
+function createOliveyoungStockStoresCacheKey(params) {
+    return JSON.stringify([params.productId, params.latitude, params.longitude, params.pageIdx, params.searchWords]);
+}
+function cloneOliveyoungProductSearchResult(result) {
+    return {
+        totalCount: result.totalCount,
+        nextPage: result.nextPage,
+        products: result.products.map((product) => ({ ...product })),
+    };
+}
+function cloneOliveyoungStoreSearchResult(result) {
+    return {
+        totalCount: result.totalCount,
+        stores: result.stores.map((store) => ({ ...store })),
+    };
+}
+function cloneOliveyoungStockStoresResult(result) {
+    return {
+        totalCount: result.totalCount,
+        inStockCount: result.inStockCount,
+        outOfStockCount: result.outOfStockCount,
+        notSoldCount: result.notSoldCount,
+        stores: result.stores.map((store) => ({ ...store })),
+    };
+}
+function readStaleResult(cache, cacheKey, cloneResult) {
+    const cached = cache.get(cacheKey);
+    if (!cached || cached.expiresAt <= Date.now()) {
+        return null;
+    }
+    return cloneResult(cached.result);
+}
+function writeStaleResult(cache, cacheKey, result, cloneResult) {
+    cache.set(cacheKey, {
+        expiresAt: Date.now() + OLIVEYOUNG_PRODUCT_SEARCH_STALE_CACHE_TTL_MS,
+        result: cloneResult(result),
+    });
+}
 async function zyteExtract(targetPath, requestBody, options = {}) {
     const { timeout = 15000, apiKey } = options;
     try {
@@ -103,20 +153,32 @@ export async function fetchOliveyoungStores(params, options = {}) {
         mapLat: params.latitude,
         mapLon: params.longitude,
     };
-    const body = await zyteExtract(OLIVEYOUNG_API.STORE_FINDER_PATH, payload, options);
-    const stores = (body.data?.storeList || []).map((store) => ({
-        storeCode: store.storeCode || '',
-        storeName: store.storeName || '',
-        address: store.address || '',
-        latitude: store.latitude || 0,
-        longitude: store.longitude || 0,
-        pickupYn: Boolean(store.pickupYn),
-        o2oRemainQuantity: store.o2oRemainQuantity || 0,
-    }));
-    return {
-        totalCount: body.data?.totalCount || 0,
-        stores,
-    };
+    const cacheKey = createOliveyoungStoreSearchCacheKey(params);
+    try {
+        const body = await zyteExtract(OLIVEYOUNG_API.STORE_FINDER_PATH, payload, options);
+        const stores = (body.data?.storeList || []).map((store) => ({
+            storeCode: store.storeCode || '',
+            storeName: store.storeName || '',
+            address: store.address || '',
+            latitude: store.latitude || 0,
+            longitude: store.longitude || 0,
+            pickupYn: Boolean(store.pickupYn),
+            o2oRemainQuantity: store.o2oRemainQuantity || 0,
+        }));
+        const result = {
+            totalCount: body.data?.totalCount || 0,
+            stores,
+        };
+        writeStaleResult(oliveyoungStoreSearchCache, cacheKey, result, cloneOliveyoungStoreSearchResult);
+        return result;
+    }
+    catch (error) {
+        const staleResult = readStaleResult(oliveyoungStoreSearchCache, cacheKey, cloneOliveyoungStoreSearchResult);
+        if (staleResult) {
+            return staleResult;
+        }
+        throw error;
+    }
 }
 export async function fetchOliveyoungProducts(params, options = {}) {
     const payload = {
@@ -126,58 +188,98 @@ export async function fetchOliveyoungProducts(params, options = {}) {
         sort: params.sort,
         size: params.size,
     };
-    const body = await zyteExtract(OLIVEYOUNG_API.PRODUCT_SEARCH_PATH, payload, options);
-    const list = body.data?.serachList || body.data?.searchList || [];
-    const products = list.map((product) => {
-        const o2oStockFlag = Boolean(product.o2oStockFlag);
-        const o2oRemainQuantity = product.o2oRemainQuantity || 0;
-        const inStock = resolveOliveyoungInStock(o2oStockFlag, o2oRemainQuantity);
-        const stockStatus = inStock ? 'in_stock' : 'out_of_stock';
-        const stockSource = 'global_search';
-        return {
-            goodsNumber: product.goodsNumber || '',
-            goodsName: product.goodsName || '',
-            imageUrl: resolveOliveyoungImageUrl(product.imagePath),
-            priceToPay: product.priceToPay || 0,
-            originalPrice: product.originalPrice || 0,
-            discountRate: product.discountRate || 0,
-            o2oStockFlag,
-            o2oRemainQuantity,
-            inStock,
-            stockStatus,
-            stockSource,
+    const cacheKey = createOliveyoungProductSearchCacheKey(params);
+    try {
+        const body = await zyteExtract(OLIVEYOUNG_API.PRODUCT_SEARCH_PATH, payload, options);
+        const list = body.data?.serachList || body.data?.searchList || [];
+        const products = list.map((product) => {
+            const o2oStockFlag = Boolean(product.o2oStockFlag);
+            const o2oRemainQuantity = product.o2oRemainQuantity || 0;
+            const inStock = resolveOliveyoungInStock(o2oStockFlag, o2oRemainQuantity);
+            const stockStatus = inStock ? 'in_stock' : 'out_of_stock';
+            const stockSource = 'global_search';
+            return {
+                goodsNumber: product.goodsNumber || '',
+                goodsName: product.goodsName || '',
+                imageUrl: resolveOliveyoungImageUrl(product.imagePath),
+                priceToPay: product.priceToPay || 0,
+                originalPrice: product.originalPrice || 0,
+                discountRate: product.discountRate || 0,
+                o2oStockFlag,
+                o2oRemainQuantity,
+                inStock,
+                stockStatus,
+                stockSource,
+            };
+        });
+        const result = {
+            totalCount: body.data?.totalCount || 0,
+            nextPage: Boolean(body.data?.nextPage),
+            products,
         };
-    });
-    return {
-        totalCount: body.data?.totalCount || 0,
-        nextPage: Boolean(body.data?.nextPage),
-        products,
-    };
+        writeStaleResult(oliveyoungProductSearchCache, cacheKey, result, cloneOliveyoungProductSearchResult);
+        return result;
+    }
+    catch (error) {
+        const staleResult = readStaleResult(oliveyoungProductSearchCache, cacheKey, cloneOliveyoungProductSearchResult);
+        if (staleResult) {
+            return staleResult;
+        }
+        throw error;
+    }
 }
 async function fetchOliveyoungProductId(goodsNumber, options = {}) {
-    const body = await zyteExtract(OLIVEYOUNG_API.STOCK_GOODS_INFO_PATH, { goodsNo: goodsNumber }, options);
-    return body.data?.goodsInfo?.masterGoodsNumber || '';
+    const normalizedGoodsNumber = goodsNumber.trim();
+    if (!normalizedGoodsNumber) {
+        return '';
+    }
+    const cached = oliveyoungProductIdCache.get(normalizedGoodsNumber);
+    const now = Date.now();
+    if (cached && cached.expiresAt > now) {
+        return cached.productId;
+    }
+    const body = await zyteExtract(OLIVEYOUNG_API.STOCK_GOODS_INFO_PATH, { goodsNo: normalizedGoodsNumber }, options);
+    const productId = body.data?.goodsInfo?.masterGoodsNumber || '';
+    if (productId) {
+        oliveyoungProductIdCache.set(normalizedGoodsNumber, {
+            expiresAt: now + OLIVEYOUNG_PRODUCT_ID_CACHE_TTL_MS,
+            productId,
+        });
+    }
+    return productId;
 }
 async function fetchOliveyoungStockStores(params, options = {}) {
-    const body = await zyteExtract(OLIVEYOUNG_API.STOCK_STORES_PATH, {
-        productId: params.productId,
-        lat: params.latitude,
-        lon: params.longitude,
-        pageIdx: params.pageIdx,
-        searchWords: params.searchWords,
-        mapLat: params.latitude,
-        mapLon: params.longitude,
-    }, options);
-    const stores = (body.data?.storeList || []).map((store) => resolveOliveyoungStoreStock(store));
-    const inStockCount = stores.filter((store) => store.stockStatus === 'in_stock').length;
-    const notSoldCount = stores.filter((store) => store.stockStatus === 'not_sold').length;
-    return {
-        totalCount: body.data?.totalCount || 0,
-        inStockCount,
-        outOfStockCount: stores.length - inStockCount - notSoldCount,
-        notSoldCount,
-        stores,
-    };
+    const cacheKey = createOliveyoungStockStoresCacheKey(params);
+    try {
+        const body = await zyteExtract(OLIVEYOUNG_API.STOCK_STORES_PATH, {
+            productId: params.productId,
+            lat: params.latitude,
+            lon: params.longitude,
+            pageIdx: params.pageIdx,
+            searchWords: params.searchWords,
+            mapLat: params.latitude,
+            mapLon: params.longitude,
+        }, options);
+        const stores = (body.data?.storeList || []).map((store) => resolveOliveyoungStoreStock(store));
+        const inStockCount = stores.filter((store) => store.stockStatus === 'in_stock').length;
+        const notSoldCount = stores.filter((store) => store.stockStatus === 'not_sold').length;
+        const result = {
+            totalCount: body.data?.totalCount || 0,
+            inStockCount,
+            outOfStockCount: stores.length - inStockCount - notSoldCount,
+            notSoldCount,
+            stores,
+        };
+        writeStaleResult(oliveyoungStockStoresCache, cacheKey, result, cloneOliveyoungStockStoresResult);
+        return result;
+    }
+    catch (error) {
+        const staleResult = readStaleResult(oliveyoungStockStoresCache, cacheKey, cloneOliveyoungStockStoresResult);
+        if (staleResult) {
+            return staleResult;
+        }
+        throw error;
+    }
 }
 function sortOliveyoungProducts(products) {
     const score = (product) => {
@@ -193,39 +295,57 @@ export async function enrichOliveyoungProductsWithNearbyStoreInventory(products,
     if (maxProducts === 0) {
         return { checkedCount: 0, products };
     }
-    const enrichedProducts = [];
-    let checkedCount = 0;
-    for (const [index, product] of products.entries()) {
-        if (index >= maxProducts) {
-            enrichedProducts.push(product);
-            continue;
+    const checkedProducts = await Promise.all(products.slice(0, maxProducts).map(async (product) => {
+        let productId = '';
+        try {
+            productId = await fetchOliveyoungProductId(product.goodsNumber, options);
+        }
+        catch {
+            return { checked: false, product };
         }
-        const productId = await fetchOliveyoungProductId(product.goodsNumber, options);
         if (!productId) {
-            enrichedProducts.push(product);
-            continue;
+            return { checked: false, product };
+        }
+        let storeInventory;
+        try {
+            storeInventory = await fetchOliveyoungStockStores({
+                productId,
+                latitude: params.latitude,
+                longitude: params.longitude,
+                pageIdx: 1,
+                searchWords: params.storeKeyword,
+            }, options);
+        }
+        catch {
+            return { checked: false, product };
         }
-        const storeInventory = await fetchOliveyoungStockStores({
-            productId,
-            latitude: params.latitude,
-            longitude: params.longitude,
-            pageIdx: 1,
-            searchWords: params.storeKeyword,
-        }, options);
-        checkedCount += 1;
         const inStock = storeInventory.inStockCount > 0;
         const stockStatus = inStock ? 'in_stock' : 'out_of_stock';
         const stockSource = 'nearby_store';
-        enrichedProducts.push({
-            ...product,
-            inStock,
-            stockStatus,
-            stockSource,
-            storeInventory,
-        });
-    }
+        return {
+            checked: true,
+            product: {
+                ...product,
+                inStock,
+                stockStatus,
+                stockSource,
+                storeInventory,
+            },
+        };
+    }));
+    const enrichedProducts = [
+        ...checkedProducts.map((result) => result.product),
+        ...products.slice(maxProducts),
+    ];
+    const checkedCount = checkedProducts.filter((result) => result.checked).length;
     return {
         checkedCount,
         products: sortOliveyoungProducts(enrichedProducts),
     };
 }
+export function __testOnlyClearOliveyoungCaches() {
+    oliveyoungProductIdCache.clear();
+    oliveyoungProductSearchCache.clear();
+    oliveyoungStoreSearchCache.clear();
+    oliveyoungStockStoresCache.clear();
+}

package/dist/services/oliveyoung/tools/checkInventory.js

@@ -4,7 +4,7 @@
 import * as z from 'zod';
 import { enrichOliveyoungProductsWithNearbyStoreInventory, fetchOliveyoungProducts, fetchOliveyoungStores, } from '../client.js';
 async function checkInventory(args) {
-    const { keyword, latitude = 37.5665, longitude = 126.978, storeKeyword = '', page = 1, size = 20, sort = '01', includeSoldOut = false, storeLimit = 10, timeoutMs = 15000, zyteApiKey, } = args;
+    const { keyword, latitude = 37.5665, longitude = 126.978, storeKeyword = '', page = 1, size = 20, sort = '01', includeSoldOut = false, storeLimit = 10, stockCheckLimit = 5, timeoutMs = 15000, zyteApiKey, } = args;
     if (!keyword || keyword.trim().length === 0) {
         throw new Error('상품 검색어(keyword)를 입력해주세요.');
     }
@@ -33,7 +33,7 @@ async function checkInventory(args) {
         latitude,
         longitude,
         storeKeyword,
-        maxProducts: Math.min(productResult.products.length, 5),
+        maxProducts: Math.min(productResult.products.length, Math.max(0, stockCheckLimit)),
     }, {
         timeout: timeoutMs,
         apiKey: zyteApiKey,
@@ -90,6 +90,11 @@ export function createCheckInventoryTool(apiKey) {
                 sort: z.string().optional().default('01').describe('정렬 코드 (기본값: 01)'),
                 includeSoldOut: z.boolean().optional().default(false).describe('품절 상품 포함 여부 (기본값: false)'),
                 storeLimit: z.number().optional().default(10).describe('반환할 주변 매장 최대 수 (기본값: 10)'),
+                stockCheckLimit: z
+                    .number()
+                    .optional()
+                    .default(5)
+                    .describe('주변 매장별 재고를 보강할 상품 수 (기본값: 5, 낮출수록 빠름)'),
                 timeoutMs: z.number().optional().default(15000).describe('요청 제한 시간(ms, 기본값: 15000)'),
             },
         },

package/dist/services/places/client.js

@@ -0,0 +1,116 @@
+const CATEGORY_KEYWORDS = {
+    restaurant: '음식점',
+    cafe: '카페',
+    food: '음식점',
+    dessert: '디저트',
+    all: '',
+};
+function getProcessEnvValue(name) {
+    /* c8 ignore next -- Node 테스트와 CLI 런타임은 process를 제공하며, Worker에는 API에서 키를 주입합니다. */
+    return typeof process !== 'undefined' ? process.env[name] : undefined;
+}
+function cleanHtml(value) {
+    if (!value) {
+        return '';
+    }
+    return value
+        .replace(/<[^>]*>/g, '')
+        .replace(/&amp;/g, '&')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .trim();
+}
+function toCoordinate(value) {
+    if (!value) {
+        return null;
+    }
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isFinite(parsed)) {
+        return null;
+    }
+    return parsed / 10000000;
+}
+function clampDisplay(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        return 5;
+    }
+    return Math.min(Math.max(Math.trunc(value), 1), 5);
+}
+function clampStart(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        return 1;
+    }
+    return Math.min(Math.max(Math.trunc(value), 1), 1000);
+}
+export function buildNaverLocalQuery({ location = '', keyword = '', category = 'all', }) {
+    const parts = [location.trim(), keyword.trim() || CATEGORY_KEYWORDS[category]].filter((part) => part.length > 0);
+    return parts.join(' ').trim();
+}
+function normalizePlace(item) {
+    return {
+        name: cleanHtml(item.title),
+        category: cleanHtml(item.category),
+        address: cleanHtml(item.address),
+        roadAddress: cleanHtml(item.roadAddress),
+        phone: cleanHtml(item.telephone),
+        link: item.link,
+        longitude: toCoordinate(item.mapx),
+        latitude: toCoordinate(item.mapy),
+        raw: item,
+    };
+}
+export async function searchNaverLocalPlaces(args) {
+    const naverClientId = args.naverClientId?.trim() || getProcessEnvValue('NAVER_CLIENT_ID')?.trim();
+    const naverClientSecret = args.naverClientSecret?.trim() || getProcessEnvValue('NAVER_CLIENT_SECRET')?.trim();
+    if (!naverClientId || !naverClientSecret) {
+        throw new Error('NAVER_CLIENT_ID와 NAVER_CLIENT_SECRET 환경 변수가 필요합니다.');
+    }
+    const category = args.category ?? 'all';
+    const location = args.location?.trim() ?? '';
+    const query = buildNaverLocalQuery({
+        location,
+        keyword: args.keyword,
+        category,
+    });
+    if (query.length === 0) {
+        throw new Error('위치(location) 또는 검색어(keyword)를 입력해주세요.');
+    }
+    const url = new URL('https://openapi.naver.com/v1/search/local.json');
+    url.searchParams.set('query', query);
+    url.searchParams.set('display', String(clampDisplay(args.limit)));
+    url.searchParams.set('start', String(clampStart(args.start)));
+    url.searchParams.set('sort', args.sort ?? 'random');
+    const fetchImpl = args.fetchImpl ?? fetch;
+    const response = await fetchImpl(url.toString(), {
+        headers: {
+            'X-Naver-Client-Id': naverClientId,
+            'X-Naver-Client-Secret': naverClientSecret,
+        },
+        signal: AbortSignal.timeout(args.timeoutMs ?? 10000),
+    });
+    const bodyText = await response.text();
+    let parsed;
+    try {
+        parsed = JSON.parse(bodyText);
+    }
+    catch {
+        parsed = {};
+    }
+    if (!response.ok) {
+        const message = parsed.errorMessage || bodyText || `HTTP ${response.status}`;
+        throw new Error(`네이버 지역 검색 실패: ${message}`);
+    }
+    const places = (parsed.items ?? []).map(normalizePlace);
+    return {
+        provider: 'naverLocal',
+        searchMode: 'keyword',
+        query,
+        category,
+        location,
+        totalCount: parsed.total ?? places.length,
+        count: places.length,
+        places,
+    };
+}

package/dist/services/places/index.js

@@ -0,0 +1,23 @@
+import { createSearchNearbyPlacesTool } from './tools/searchNearby.js';
+const PLACES_METADATA = {
+    id: 'places',
+    name: '장소 검색',
+    version: '1.0.0',
+    description: '네이버 지역 검색 기반 음식점, 카페, 주변 장소 탐색 서비스',
+};
+class PlacesService {
+    options;
+    metadata = PLACES_METADATA;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    getTools() {
+        return [
+            createSearchNearbyPlacesTool(this.options.naverClientId, this.options.naverClientSecret),
+        ];
+    }
+}
+export function createPlacesService(options = {}) {
+    return new PlacesService(options);
+}
+export * from './types.js';

package/dist/services/places/tools/searchNearby.js

@@ -0,0 +1,56 @@
+/**
+ * 네이버 지역 검색 기반 주변 장소 탐색 도구
+ */
+import * as z from 'zod';
+import { searchNaverLocalPlaces } from '../client.js';
+async function searchNearbyPlaces(args) {
+    const result = await searchNaverLocalPlaces(args);
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify(result, null, 2),
+            },
+        ],
+        structuredContent: result,
+    };
+}
+export function createSearchNearbyPlacesTool(naverClientId, naverClientSecret) {
+    return {
+        name: 'places_search_nearby',
+        metadata: {
+            title: '주변 음식점/카페 검색',
+            description: '네이버 지역 검색으로 특정 지역의 음식점, 카페, 디저트 가게 등 주변 장소를 키워드 기반으로 찾습니다.',
+            inputSchema: {
+                location: z.string().optional().describe('지역/역/주소 키워드 (예: 강남역, 성수동)'),
+                keyword: z.string().optional().describe('검색어 (예: 라멘, 브런치, 조용한 카페)'),
+                category: z
+                    .enum(['restaurant', 'cafe', 'food', 'dessert', 'all'])
+                    .optional()
+                    .default('all')
+                    .describe('장소 카테고리. restaurant/food=음식점, cafe=카페, dessert=디저트'),
+                limit: z
+                    .number()
+                    .optional()
+                    .default(5)
+                    .describe('반환할 최대 장소 수 (네이버 지역 검색 최대 5)'),
+                start: z.number().optional().default(1).describe('검색 시작 위치 (기본값: 1)'),
+                sort: z
+                    .enum(['random', 'comment'])
+                    .optional()
+                    .default('random')
+                    .describe('정렬 방식. random=유사도순, comment=리뷰순'),
+                timeoutMs: z
+                    .number()
+                    .optional()
+                    .default(10000)
+                    .describe('요청 제한 시간(ms, 기본값: 10000)'),
+            },
+        },
+        handler: ((args) => searchNearbyPlaces({
+            ...args,
+            naverClientId: args.naverClientId || naverClientId,
+            naverClientSecret: args.naverClientSecret || naverClientSecret,
+        })),
+    };
+}

package/dist/services/places/types.js

@@ -0,0 +1 @@
+export {};

package/dist/services/seveneleven/client.js

@@ -9,6 +9,10 @@ const SEVENELEVEN_DEFAULT_HEADERS = {
     'Content-Type': 'application/json',
     'User-Agent': 'Mozilla/5.0 (Linux; Android 15)',
 };
+const SEVENELEVEN_DEFAULT_FETCH_OPTIONS = {
+    retries: 1,
+    retryDelayMs: 250,
+};
 function toNumber(value) {
     if (typeof value === 'number') {
         return Number.isFinite(value) ? value : 0;
@@ -108,7 +112,9 @@ async function requestSevenElevenJson(path, method, body, options = {}) {
     const { timeout = 15000 } = options;
     const url = `${SEVENELEVEN_API.BASE_URL}${path}`;
     return fetchJson(url, {
+        ...SEVENELEVEN_DEFAULT_FETCH_OPTIONS,
         method,
+        retryUnsafeMethods: method === 'POST',
         timeout,
         headers: SEVENELEVEN_DEFAULT_HEADERS,
         body: method === 'POST' ? JSON.stringify(body || {}) : undefined,
@@ -211,6 +217,7 @@ export async function fetchSevenElevenStockProductMeta(itemCode, options = {}) {
     const encodedItemCode = encodeURIComponent(itemCode.trim());
     const url = `${SEVENELEVEN_API.BASE_URL}${SEVENELEVEN_API.PRODUCT_SEARCH_STOCK_PATH}?itemCd=${encodedItemCode}`;
     const response = await fetchJson(url, {
+        ...SEVENELEVEN_DEFAULT_FETCH_OPTIONS,
         method: 'GET',
         timeout,
         headers: {