daiso 1.0.10 → 1.2.0

package/dist/api/healthCheckShape.js

@@ -17,7 +17,7 @@ export function toCount(data) {
     }
     if (record.inventory && typeof record.inventory === 'object') {
         const inventory = record.inventory;
-        for (const key of ['products', 'items']) {
+        for (const key of ['products', 'items', 'stores']) {
             const value = inventory[key];
             if (Array.isArray(value)) {
                 return value.length;
@@ -37,7 +37,15 @@ export function toFirstName(data) {
             continue;
         }
         const item = value[0];
-        for (const nameKey of ['productName', 'itemName', 'goodsName', 'name', 'storeName', 'theaterName', 'movieName']) {
+        for (const nameKey of [
+            'productName',
+            'itemName',
+            'goodsName',
+            'name',
+            'storeName',
+            'theaterName',
+            'movieName',
+        ]) {
             if (typeof item[nameKey] === 'string' && item[nameKey].trim().length > 0) {
                 return item[nameKey].trim();
             }
@@ -45,13 +53,13 @@ export function toFirstName(data) {
     }
     if (record.inventory && typeof record.inventory === 'object') {
         const inventory = record.inventory;
-        for (const key of ['products', 'items']) {
+        for (const key of ['products', 'items', 'stores']) {
             const value = inventory[key];
             if (!Array.isArray(value) || !value[0] || typeof value[0] !== 'object') {
                 continue;
             }
             const item = value[0];
-            for (const nameKey of ['productName', 'itemName', 'goodsName', 'name']) {
+            for (const nameKey of ['productName', 'itemName', 'goodsName', 'name', 'storeName']) {
                 if (typeof item[nameKey] === 'string' && item[nameKey].trim().length > 0) {
                     return item[nameKey].trim();
                 }
@@ -65,12 +73,18 @@ function getCollectionItems(data, collectionKey) {
         return [];
     }
     const record = data;
-    if (collectionKey === 'inventoryProducts' || collectionKey === 'inventoryItems') {
+    if (collectionKey === 'inventoryProducts' ||
+        collectionKey === 'inventoryItems' ||
+        collectionKey === 'inventoryStores') {
         const inventory = record.inventory;
         if (!inventory || typeof inventory !== 'object') {
             return [];
         }
-        const key = collectionKey === 'inventoryProducts' ? 'products' : 'items';
+        const key = collectionKey === 'inventoryProducts'
+            ? 'products'
+            : collectionKey === 'inventoryStores'
+                ? 'stores'
+                : 'items';
         const value = inventory[key];
         return Array.isArray(value) ? value : [];
     }
@@ -92,7 +106,7 @@ export function hasRequiredRepresentativeFields(data, collectionKey, requiredFie
     }
     const items = getCollectionItems(data, collectionKey);
     if (items.length === 0) {
-        return true;
+        return false;
     }
     const first = items[0];
     if (!first || typeof first !== 'object' || Array.isArray(first)) {
@@ -101,6 +115,8 @@ export function hasRequiredRepresentativeFields(data, collectionKey, requiredFie
     const record = first;
     return requiredFields.some((field) => {
         const value = record[field];
-        return typeof value === 'string' ? value.trim().length > 0 : value !== undefined && value !== null;
+        return typeof value === 'string'
+            ? value.trim().length > 0
+            : value !== undefined && value !== null;
     });
 }

package/dist/api/healthChecks.js

@@ -65,6 +65,9 @@ function aggregateStatus(checks) {
     if (checks.some((check) => check.status === 'degraded')) {
         return 'degraded';
     }
+    if (checks.every((check) => check.status === 'skipped')) {
+        return 'skipped';
+    }
     return 'ok';
 }
 function shouldDegradeFailedResponse(check, message) {
@@ -82,18 +85,6 @@ function shouldDegradeCliContractPath(path, message) {
     }
     return false;
 }
-function resolveCheckTimeoutMs(check, timeoutMs) {
-    if (check.timeoutMs === undefined) {
-        return timeoutMs;
-    }
-    return Math.min(timeoutMs, Math.trunc(check.timeoutMs));
-}
-function resolveCliContractTimeoutMs(path, timeoutMs) {
-    if (path.startsWith('/api/oliveyoung/')) {
-        return Math.min(timeoutMs, 5000);
-    }
-    return timeoutMs;
-}
 function buildCheckUrl(baseUrl, check, timeoutMs, cacheBustValue) {
     const url = new URL(check.path, baseUrl);
     url.searchParams.set('timeoutMs', String(timeoutMs));
@@ -131,7 +122,7 @@ async function runCliContractCheck(check, params) {
     const cacheBustValue = params.cacheBust ? startedAt : undefined;
     const degradedMessages = [];
     for (const path of CLI_CONTRACT_PATHS) {
-        const checkTimeoutMs = resolveCliContractTimeoutMs(path, params.timeoutMs);
+        const checkTimeoutMs = params.timeoutMs;
         const syntheticCheck = { ...check, path };
         try {
             const response = await params.fetchImpl(buildCheckUrl(params.baseUrl, syntheticCheck, checkTimeoutMs, cacheBustValue), {
@@ -181,7 +172,7 @@ async function runSingleCheck(check, params) {
     if (check.kind === 'cli-contract') {
         return runCliContractCheck(check, params);
     }
-    const timeoutMs = resolveCheckTimeoutMs(check, params.timeoutMs);
+    const timeoutMs = params.timeoutMs;
     const startedAt = params.now();
     const cacheBustValue = params.cacheBust ? startedAt : undefined;
     try {
@@ -202,19 +193,41 @@ async function runSingleCheck(check, params) {
                 message,
             };
         }
+        const inventory = body.data?.inventory;
+        if (check.id === 'cu.inventory' && inventory?.available === false) {
+            const reason = inventory.unavailableReason;
+            return {
+                id: check.id,
+                service: check.service,
+                target: check.target,
+                status: 'degraded',
+                durationMs,
+                httpStatus: response.status,
+                message: typeof reason === 'string' && reason.trim() ? reason.trim() : 'inventory unavailable',
+            };
+        }
         const count = typeof body.meta?.total === 'number' ? body.meta.total : toCount(body.data);
         const shapeOk = hasRequiredRepresentativeFields(body.data, check.collectionKey, check.requiredFields);
         const slowThresholdMs = params.slowThresholdMs || DEFAULT_HEALTH_CHECK_SLOW_THRESHOLD_MS;
         const slow = slowThresholdMs > 0 && durationMs > slowThresholdMs;
-        const status = count === 0 || !shapeOk || slow ? 'degraded' : 'ok';
+        const optionalEmpty = check.allowEmpty === true && count === 0;
+        const status = slow
+            ? 'degraded'
+            : optionalEmpty
+                ? 'skipped'
+                : count === null || count === 0 || !shapeOk
+                    ? 'degraded'
+                    : 'ok';
         const first = params.includeSamples ? toFirstName(body.data) : undefined;
         const message = slow
             ? `slow response: ${durationMs}ms > ${slowThresholdMs}ms`
-            : !shapeOk && count !== 0
-                ? `response missing required fields: ${check.requiredFields.join(', ')}`
+            : optionalEmpty
+                ? 'optional data unavailable'
                 : count === null
-                    ? 'response ok'
-                    : `${count} item(s) returned`;
+                    ? 'response count unavailable'
+                    : !shapeOk && count !== 0
+                        ? `response missing required fields: ${check.requiredFields.join(', ')}`
+                        : `${count} item(s) returned`;
         return {
             id: check.id,
             service: check.service,
@@ -245,7 +258,13 @@ export async function runHealthChecks(params) {
     const slowThresholdMs = Number.isFinite(params.slowThresholdMs) && params.slowThresholdMs && params.slowThresholdMs > 0
         ? Math.trunc(params.slowThresholdMs)
         : DEFAULT_HEALTH_CHECK_SLOW_THRESHOLD_MS;
-    const cacheKey = createCacheKey({ ...params, mode, timeoutMs, slowThresholdMs, baseUrl: params.baseUrl });
+    const cacheKey = createCacheKey({
+        ...params,
+        mode,
+        timeoutMs,
+        slowThresholdMs,
+        baseUrl: params.baseUrl,
+    });
     const cached = healthCheckCache.get(cacheKey);
     const startedAt = now();
     if (!params.fresh && cached && cached.expiresAt > startedAt) {

package/dist/api/operationalAuth.js

@@ -0,0 +1,32 @@
+const textEncoder = new TextEncoder();
+export function readOperationalToken(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();
+}
+async function digestToken(token) {
+    return crypto.subtle.digest('SHA-256', textEncoder.encode(token));
+}
+async function compareDigests(left, right) {
+    const timingSafeEqual = crypto.subtle.timingSafeEqual;
+    if (typeof timingSafeEqual === 'function') {
+        return timingSafeEqual.call(crypto.subtle, left, right);
+    }
+    // Node Web Crypto에는 Workers 확장 메서드가 없으므로 네이티브 HMAC 검증으로 비교한다.
+    const key = await crypto.subtle.importKey('raw', right, { name: 'HMAC', hash: 'SHA-256' }, false, ['sign', 'verify']);
+    const signature = await crypto.subtle.sign('HMAC', key, right);
+    return crypto.subtle.verify('HMAC', key, signature, left);
+}
+export async function authorizeOperationalRequest(headers, configuredSecret) {
+    const secret = configuredSecret?.trim();
+    if (!secret) {
+        return 'not-configured';
+    }
+    const [requestDigest, secretDigest] = await Promise.all([
+        digestToken(readOperationalToken(headers)),
+        digestToken(secret),
+    ]);
+    return (await compareDigests(requestDigest, secretDigest)) ? 'authorized' : 'unauthorized';
+}

package/dist/api/routes/dtryxRoutes.js

@@ -0,0 +1,22 @@
+/**
+ * 디트릭스 GET API 라우트 등록
+ */
+import { withEdgeCache } from '../../utils/cache.js';
+import { handleDtryxGetRemainingSeats, handleDtryxListCinemas, handleDtryxListNowShowing, } from '../dtryxHandlers.js';
+export function registerDtryxRoutes(app) {
+    app.get('/api/dtryx/cinemas', async (c) => withEdgeCache(c.req.url, {
+        ttlSeconds: 60 * 60 * 24,
+        staleWhileRevalidateSeconds: 60 * 5,
+        keyPrefix: 'dtryx-cinemas-v1',
+    }, () => handleDtryxListCinemas(c)));
+    app.get('/api/dtryx/movies', async (c) => withEdgeCache(c.req.url, {
+        ttlSeconds: 60 * 10,
+        staleWhileRevalidateSeconds: 60,
+        keyPrefix: 'dtryx-movies-v1',
+    }, () => handleDtryxListNowShowing(c)));
+    app.get('/api/dtryx/seats', async (c) => withEdgeCache(c.req.url, {
+        ttlSeconds: 60 * 3,
+        staleWhileRevalidateSeconds: 30,
+        keyPrefix: 'dtryx-seats-v1',
+    }, () => handleDtryxGetRemainingSeats(c)));
+}

package/dist/api/routes/healthRoutes.js

@@ -3,17 +3,11 @@
  */
 import { errorResponse } from '../response.js';
 import { runHealthChecks } from '../healthChecks.js';
+import { authorizeOperationalRequest } from '../operationalAuth.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 isBetterStackHealthProbe(userAgent) {
     const normalized = (userAgent || '').toLowerCase();
     return normalized.includes('better stack better uptime bot') || normalized === 'nginx-ssl early hints';
@@ -24,6 +18,13 @@ function isEarlyHintsProbe(userAgent) {
 function canForceFresh(headers) {
     return parseBoolean(headers.get('x-health-check-force-fresh') || undefined);
 }
+function isTrustedHealthTarget(target, requestUrl, configuredBaseUrl) {
+    const allowedOrigins = new Set([new URL(requestUrl).origin]);
+    if (configuredBaseUrl) {
+        allowedOrigins.add(new URL(configuredBaseUrl).origin);
+    }
+    return allowedOrigins.has(new URL(String(target)).origin);
+}
 function parseMode(value) {
     if (!value || value === 'quick') {
         return 'quick';
@@ -43,7 +44,7 @@ export function registerHealthRoutes(app) {
         if (!secret) {
             return errorResponse(c, 'HEALTH_CHECK_SECRET_NOT_CONFIGURED', 'HEALTH_CHECK_SECRET이 설정되어 있지 않습니다.', 503);
         }
-        if (readHealthCheckToken(c.req.raw.headers) !== secret) {
+        if ((await authorizeOperationalRequest(c.req.raw.headers, secret)) !== 'authorized') {
             return errorResponse(c, 'UNAUTHORIZED_HEALTH_CHECK', '유효한 헬스 체크 시크릿 키가 필요합니다.', 401);
         }
         const mode = parseMode(c.req.query('mode'));
@@ -55,9 +56,16 @@ export function registerHealthRoutes(app) {
         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 = transport !== 'network'
-            ? async (input, init) => app.fetch(new Request(input, init), c.env)
-            : undefined;
+        const fetchImpl = async (input, init) => {
+            const headers = new Headers(init?.headers);
+            if (isTrustedHealthTarget(input, c.req.url, c.env?.HEALTH_CHECK_BASE_URL)) {
+                headers.set('x-health-check-key', secret);
+            }
+            const requestInit = { ...init, headers };
+            return transport !== 'network'
+                ? app.fetch(new Request(input, requestInit), c.env)
+                : globalThis.fetch(input, requestInit);
+        };
         const result = await runHealthChecks({
             baseUrl,
             service: c.req.query('service') || undefined,

package/dist/api/routes/rateLimitStatsRoutes.js

@@ -0,0 +1,274 @@
+/**
+ * 인증된 일일 호출 제한 집계 조회 라우트
+ */
+import { RATE_LIMIT_METRICS_LEDGER_NAME, RATE_LIMIT_METRICS_RETENTION_DAYS, RATE_LIMIT_SERVICES, } from '../../durableObjects/rateLimitMetricsStore.js';
+import { authorizeOperationalRequest } from '../operationalAuth.js';
+import { errorResponse, successResponse } from '../response.js';
+const KST_OFFSET_MS = 9 * 60 * 60 * 1000;
+const DEFAULT_RANGE_DAYS = 7;
+const DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
+const ALLOWED_QUERY_KEYS = new Set(['from', 'to', 'service']);
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isExactDate(value) {
+    if (typeof value !== 'string' || !DATE_PATTERN.test(value)) {
+        return false;
+    }
+    const timestamp = Date.parse(`${value}T00:00:00.000Z`);
+    return Number.isFinite(timestamp) && new Date(timestamp).toISOString().slice(0, 10) === value;
+}
+function isRateLimitService(value) {
+    return typeof value === 'string' && RATE_LIMIT_SERVICES.includes(value);
+}
+function toKstDay(nowMs) {
+    return new Date(nowMs + KST_OFFSET_MS).toISOString().slice(0, 10);
+}
+function addCalendarDays(day, days) {
+    const date = new Date(`${day}T00:00:00.000Z`);
+    date.setUTCDate(date.getUTCDate() + days);
+    return date.toISOString().slice(0, 10);
+}
+function inclusiveDayCount(from, to) {
+    const fromMs = Date.parse(`${from}T00:00:00.000Z`);
+    const toMs = Date.parse(`${to}T00:00:00.000Z`);
+    return (toMs - fromMs) / (24 * 60 * 60 * 1000) + 1;
+}
+function hasStrictQueryShape(searchParams) {
+    const counts = new Map();
+    for (const [key] of searchParams) {
+        if (!ALLOWED_QUERY_KEYS.has(key)) {
+            return false;
+        }
+        const count = (counts.get(key) ?? 0) + 1;
+        if (count > 1) {
+            return false;
+        }
+        counts.set(key, count);
+    }
+    return counts.has('from') === counts.has('to');
+}
+function parseStatsInput(url, nowMs) {
+    if (!hasStrictQueryShape(url.searchParams)) {
+        return undefined;
+    }
+    const serviceValue = url.searchParams.get('service');
+    if (serviceValue !== null && !isRateLimitService(serviceValue)) {
+        return undefined;
+    }
+    const currentDay = toKstDay(nowMs);
+    const earliestDay = addCalendarDays(currentDay, -(RATE_LIMIT_METRICS_RETENTION_DAYS - 1));
+    const fromValue = url.searchParams.get('from');
+    const toValue = url.searchParams.get('to');
+    const from = fromValue ?? addCalendarDays(currentDay, -(DEFAULT_RANGE_DAYS - 1));
+    const to = toValue ?? currentDay;
+    if (!isExactDate(from) ||
+        !isExactDate(to) ||
+        from > to ||
+        from < earliestDay ||
+        to > currentDay ||
+        inclusiveDayCount(from, to) > RATE_LIMIT_METRICS_RETENTION_DAYS) {
+        return undefined;
+    }
+    return serviceValue === null
+        ? { from, to, asOfDay: currentDay }
+        : { from, to, asOfDay: currentDay, service: serviceValue };
+}
+function sanitizeAggregate(value) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    const { blockedRequests, uniqueIdentities } = value;
+    if (typeof blockedRequests !== 'number' ||
+        !Number.isSafeInteger(blockedRequests) ||
+        blockedRequests < 0 ||
+        typeof uniqueIdentities !== 'number' ||
+        !Number.isSafeInteger(uniqueIdentities) ||
+        uniqueIdentities < 0 ||
+        uniqueIdentities > blockedRequests) {
+        return undefined;
+    }
+    return { blockedRequests, uniqueIdentities };
+}
+function sanitizeDailyRows(value, input) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const rows = [];
+    let previousDay;
+    for (const valueRow of value) {
+        if (!isRecord(valueRow)) {
+            return undefined;
+        }
+        const aggregate = sanitizeAggregate(valueRow);
+        const { day } = valueRow;
+        if (!aggregate ||
+            !isExactDate(day) ||
+            day < input.from ||
+            day > input.to ||
+            (previousDay !== undefined && day <= previousDay)) {
+            return undefined;
+        }
+        rows.push({ day, ...aggregate });
+        previousDay = day;
+    }
+    return rows;
+}
+function sanitizeServiceRows(value, input) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const rows = [];
+    let previousKey;
+    for (const valueRow of value) {
+        if (!isRecord(valueRow)) {
+            return undefined;
+        }
+        const aggregate = sanitizeAggregate(valueRow);
+        const { day, service } = valueRow;
+        const key = `${String(day)}\u0000${String(service)}`;
+        if (!aggregate ||
+            !isExactDate(day) ||
+            day < input.from ||
+            day > input.to ||
+            !isRateLimitService(service) ||
+            (input.service !== undefined && service !== input.service) ||
+            (previousKey !== undefined && key <= previousKey)) {
+            return undefined;
+        }
+        rows.push({ day, service, ...aggregate });
+        previousKey = key;
+    }
+    return rows;
+}
+function sumBlockedRequests(rows) {
+    let total = 0;
+    for (const row of rows) {
+        total += row.blockedRequests;
+        if (!Number.isSafeInteger(total)) {
+            return undefined;
+        }
+    }
+    return total;
+}
+function hasValidGroupedRelations(stats, input) {
+    const { totals, daily, services } = stats;
+    if (totals.blockedRequests === 0) {
+        return totals.uniqueIdentities === 0 && daily.length === 0 && services.length === 0;
+    }
+    const dailyUniqueSum = daily.reduce((sum, row) => sum + row.uniqueIdentities, 0);
+    if (totals.uniqueIdentities > dailyUniqueSum ||
+        daily.some((row) => row.blockedRequests === 0 ||
+            row.uniqueIdentities === 0 ||
+            row.uniqueIdentities > totals.uniqueIdentities) ||
+        services.some((row) => row.blockedRequests === 0 ||
+            row.uniqueIdentities === 0 ||
+            row.uniqueIdentities > totals.uniqueIdentities)) {
+        return false;
+    }
+    const dailyByDay = new Map(daily.map((row) => [row.day, row]));
+    const servicesByDay = new Map(daily.map((row) => [row.day, []]));
+    for (const row of services) {
+        const dailyRow = dailyByDay.get(row.day);
+        if (!dailyRow || row.uniqueIdentities > dailyRow.uniqueIdentities) {
+            return false;
+        }
+        servicesByDay.get(row.day).push(row);
+    }
+    return daily.every((dailyRow) => {
+        const dayServices = servicesByDay.get(dailyRow.day);
+        if (input.service !== undefined) {
+            const serviceRow = dayServices[0];
+            return (dayServices.length === 1 &&
+                serviceRow?.service === input.service &&
+                serviceRow.blockedRequests === dailyRow.blockedRequests &&
+                serviceRow.uniqueIdentities === dailyRow.uniqueIdentities);
+        }
+        const blockedRequests = dayServices.reduce((sum, row) => sum + row.blockedRequests, 0);
+        const uniqueIdentities = dayServices.map((row) => row.uniqueIdentities);
+        const uniqueSum = uniqueIdentities.reduce((sum, count) => sum + count, 0);
+        const uniqueMaximum = Math.max(0, ...uniqueIdentities);
+        return (blockedRequests === dailyRow.blockedRequests &&
+            dailyRow.uniqueIdentities >= uniqueMaximum &&
+            dailyRow.uniqueIdentities <= uniqueSum);
+    });
+}
+function sanitizeStats(value, input) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    const totals = sanitizeAggregate(value.totals);
+    const daily = sanitizeDailyRows(value.daily, input);
+    const services = sanitizeServiceRows(value.services, input);
+    if (!totals || !daily || !services) {
+        return undefined;
+    }
+    if (sumBlockedRequests(daily) !== totals.blockedRequests ||
+        sumBlockedRequests(services) !== totals.blockedRequests) {
+        return undefined;
+    }
+    const stats = { totals, daily, services };
+    return hasValidGroupedRelations(stats, input) ? stats : undefined;
+}
+function unavailableResponse(c) {
+    return errorResponse(c, 'RATE_LIMIT_STATS_UNAVAILABLE', '호출 제한 통계를 조회할 수 없습니다.', 503);
+}
+export function registerRateLimitStatsRoutes(app) {
+    app.get('/api/rate-limit/stats', async (c) => {
+        const authorization = await authorizeOperationalRequest(c.req.raw.headers, c.env?.HEALTH_CHECK_SECRET);
+        if (authorization === 'not-configured') {
+            return errorResponse(c, 'HEALTH_CHECK_SECRET_NOT_CONFIGURED', 'HEALTH_CHECK_SECRET이 설정되어 있지 않습니다.', 503);
+        }
+        if (authorization === 'unauthorized') {
+            return errorResponse(c, 'UNAUTHORIZED_RATE_LIMIT_STATS', '유효한 운영 시크릿 키가 필요합니다.', 401);
+        }
+        const input = parseStatsInput(new URL(c.req.url), Date.now());
+        if (!input) {
+            return errorResponse(c, 'INVALID_RATE_LIMIT_STATS_QUERY', '통계 조회 조건이 올바르지 않습니다.', 400);
+        }
+        const namespace = c.env?.DAILY_RATE_LIMITER;
+        if (!namespace) {
+            console.error('호출 제한 통계 binding 누락');
+            return unavailableResponse(c);
+        }
+        let response;
+        try {
+            const id = namespace.idFromName(RATE_LIMIT_METRICS_LEDGER_NAME);
+            const stub = namespace.get(id);
+            const backendUrl = new URL('https://daily-rate-limit/stats');
+            backendUrl.searchParams.set('from', input.from);
+            backendUrl.searchParams.set('to', input.to);
+            backendUrl.searchParams.set('asOf', input.asOfDay);
+            if (input.service !== undefined) {
+                backendUrl.searchParams.set('service', input.service);
+            }
+            response = await stub.fetch(backendUrl.toString(), { method: 'GET' });
+        }
+        catch {
+            console.error('호출 제한 통계 Durable Object 호출 실패');
+            return unavailableResponse(c);
+        }
+        if (response.status !== 200) {
+            console.error('호출 제한 통계 Durable Object 응답 실패', response.status);
+            return unavailableResponse(c);
+        }
+        let value;
+        try {
+            value = await response.json();
+        }
+        catch {
+            console.error('호출 제한 통계 응답 검증 실패');
+            return unavailableResponse(c);
+        }
+        const stats = sanitizeStats(value, input);
+        if (!stats) {
+            console.error('호출 제한 통계 응답 검증 실패');
+            return unavailableResponse(c);
+        }
+        if (toKstDay(Date.now()) !== input.asOfDay) {
+            console.error('호출 제한 통계 날짜 전환 감지');
+            return unavailableResponse(c);
+        }
+        return successResponse(c, stats);
+    });
+}

package/dist/api/routes/registerServiceRoutes.js

@@ -0,0 +1,37 @@
+/**
+ * 도메인별 GET API 라우트 일괄 등록
+ *
+ * `src/index.ts` 의 길이 제한(450줄)을 유지하기 위해 분리했습니다.
+ */
+import { registerCgvRoutes } from './cgvRoutes.js';
+import { registerCompareRoutes } from './compareRoutes.js';
+import { registerCuRoutes } from './cuRoutes.js';
+import { registerDaisoRoutes } from './daisoRoutes.js';
+import { registerDtryxRoutes } from './dtryxRoutes.js';
+import { registerEmart24Routes } from './emart24Routes.js';
+import { registerFeedbackRoutes } from './feedbackRoutes.js';
+import { registerGs25Routes } from './gs25Routes.js';
+import { registerLotteCinemaRoutes } from './lottecinemaRoutes.js';
+import { registerLotteMartRoutes } from './lottemartRoutes.js';
+import { registerMegaboxRoutes } from './megaboxRoutes.js';
+import { registerOliveyoungRoutes } from './oliveyoungRoutes.js';
+import { registerOpinetRoutes } from './opinetRoutes.js';
+import { registerPlacesRoutes } from './placesRoutes.js';
+import { registerSevenElevenRoutes } from './sevenelevenRoutes.js';
+export function registerServiceRoutes(app) {
+    registerDaisoRoutes(app);
+    registerGs25Routes(app);
+    registerSevenElevenRoutes(app);
+    registerCompareRoutes(app);
+    registerFeedbackRoutes(app);
+    registerPlacesRoutes(app);
+    registerOpinetRoutes(app);
+    registerCuRoutes(app);
+    registerEmart24Routes(app);
+    registerLotteMartRoutes(app);
+    registerOliveyoungRoutes(app);
+    registerDtryxRoutes(app);
+    registerMegaboxRoutes(app);
+    registerLotteCinemaRoutes(app);
+    registerCgvRoutes(app);
+}

package/dist/api/sevenelevenHandlers.js

@@ -36,7 +36,7 @@ export async function handleSevenElevenSearchProducts(c) {
             page,
             size,
             sort,
-        });
+        }, { zyteApiKey: c.env?.ZYTE_API_KEY });
         return successResponse(c, {
             query: result.query,
             count: result.products.length,
@@ -69,7 +69,7 @@ export async function handleSevenElevenSearchStores(c) {
         const result = await fetchSevenElevenStoresByKeyword({
             keyword,
             limit: safeLimit,
-        });
+        }, { zyteApiKey: c.env?.ZYTE_API_KEY });
         return successResponse(c, {
             keyword: result.query,
             count: result.stores.length,
@@ -107,6 +107,7 @@ export async function handleSevenElevenCheckInventory(c) {
             storeLimit: safeStoreLimit,
         }, {
             timeout: safeTimeoutMs,
+            zyteApiKey: c.env?.ZYTE_API_KEY,
         });
         const note = result.stockAvailable
             ? '실시간 재고 데이터가 포함되어 있습니다.'
@@ -143,7 +144,9 @@ export async function handleSevenElevenCheckInventory(c) {
 export async function handleSevenElevenGetSearchPopwords(c) {
     const label = c.req.query('label') || 'home';
     try {
-        const keywords = await fetchSevenElevenSearchPopwords(label);
+        const keywords = await fetchSevenElevenSearchPopwords(label, {
+            zyteApiKey: c.env?.ZYTE_API_KEY,
+        });
         return successResponse(c, {
             label,
             available: keywords.length > 0,
@@ -171,6 +174,7 @@ export async function handleSevenElevenGetCatalogSnapshot(c) {
         const result = await fetchSevenElevenCatalogSnapshot({
             includeIssues,
             includeExhibition,
+            zyteApiKey: c.env?.ZYTE_API_KEY,
         });
         return successResponse(c, {
             options: {