daiso 1.0.0

package/dist/utils/cache.js

@@ -0,0 +1,54 @@
+/**
+ * Cloudflare Edge Cache 유틸리티
+ *
+ * caches.default를 사용할 수 있는 런타임에서만 동작하며,
+ * 로컬(Node) 테스트 환경에서는 자동으로 캐시를 건너뜁니다.
+ */
+function getCacheStorage() {
+    const globalObject = globalThis;
+    return globalObject.caches;
+}
+function createCacheKey(urlString, keyPrefix) {
+    const url = new URL(urlString);
+    const normalized = new URL(`${url.origin}${url.pathname}`);
+    const sortedEntries = Array.from(url.searchParams.entries()).sort(([a], [b]) => a.localeCompare(b));
+    for (const [key, value] of sortedEntries) {
+        normalized.searchParams.append(key, value);
+    }
+    if (keyPrefix) {
+        normalized.searchParams.append('__cache_prefix', keyPrefix);
+    }
+    return new Request(normalized.toString(), { method: 'GET' });
+}
+function buildCacheControl(options) {
+    const { ttlSeconds, staleWhileRevalidateSeconds = 30 } = options;
+    return [
+        `public`,
+        `max-age=${ttlSeconds}`,
+        `s-maxage=${ttlSeconds}`,
+        `stale-while-revalidate=${staleWhileRevalidateSeconds}`,
+    ].join(', ');
+}
+/**
+ * GET 응답을 Cloudflare Edge Cache에 저장/조회합니다.
+ */
+export async function withEdgeCache(requestUrl, options, fetcher) {
+    const cacheStorage = getCacheStorage();
+    const cache = cacheStorage?.default;
+    if (!cache) {
+        return fetcher();
+    }
+    const cacheKey = createCacheKey(requestUrl, options.keyPrefix);
+    const cachedResponse = await cache.match(cacheKey);
+    if (cachedResponse) {
+        return cachedResponse;
+    }
+    const response = await fetcher();
+    if (!response.ok) {
+        return response;
+    }
+    const cacheControl = buildCacheControl(options);
+    response.headers.set('Cache-Control', cacheControl);
+    await cache.put(cacheKey, response.clone());
+    return response;
+}

package/dist/utils/fetch.js

@@ -0,0 +1,14 @@
+/**
+ * HTTP 요청 유틸리티
+ */
+import { fetchJson as fetchJsonByHttp, fetchText as fetchTextByHttp, fetchWithTimeout, } from './http.js';
+// JSON 응답을 위한 fetch
+export async function fetchJson(url, options = {}) {
+    return fetchJsonByHttp(url, options);
+}
+// HTML 응답을 위한 fetch
+export async function fetchHtml(url, options = {}) {
+    return fetchTextByHttp(url, options);
+}
+// 하위 호환을 위한 별칭 (기존 이름 유지)
+export const daisoFetch = fetchWithTimeout;

package/dist/utils/format.js

@@ -0,0 +1,31 @@
+/**
+ * 숫자/시간/날짜 포맷 공용 유틸리티
+ */
+export function toNumber(value) {
+    if (typeof value === 'number') {
+        return value;
+    }
+    if (typeof value === 'string') {
+        const parsed = parseInt(value, 10);
+        return Number.isFinite(parsed) ? parsed : 0;
+    }
+    return 0;
+}
+export function formatTime(raw) {
+    if (!raw) {
+        return '';
+    }
+    if (raw.includes(':')) {
+        return raw;
+    }
+    if (raw.length === 4) {
+        return `${raw.slice(0, 2)}:${raw.slice(2)}`;
+    }
+    return raw;
+}
+export function toYyyymmdd(value = new Date()) {
+    const year = value.getFullYear();
+    const month = `${value.getMonth() + 1}`.padStart(2, '0');
+    const day = `${value.getDate()}`.padStart(2, '0');
+    return `${year}${month}${day}`;
+}

package/dist/utils/http.js

@@ -0,0 +1,35 @@
+/**
+ * 공용 HTTP 유틸리티
+ */
+export function createTimeoutController(timeout) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    return { controller, timeoutId };
+}
+export async function fetchWithTimeout(url, options = {}) {
+    const { timeout = 10000, ...restOptions } = options;
+    const { controller, timeoutId } = createTimeoutController(timeout);
+    try {
+        return await fetch(url, {
+            ...restOptions,
+            signal: controller.signal,
+        });
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+}
+export async function fetchJson(url, options = {}) {
+    const response = await fetchWithTimeout(url, options);
+    if (!response.ok) {
+        throw new Error(`API 요청 실패: ${response.status} ${response.statusText}`);
+    }
+    return response.json();
+}
+export async function fetchText(url, options = {}) {
+    const response = await fetchWithTimeout(url, options);
+    if (!response.ok) {
+        throw new Error(`API 요청 실패: ${response.status} ${response.statusText}`);
+    }
+    return response.text();
+}

package/dist/utils/zyte.js

@@ -0,0 +1,76 @@
+/**
+ * Zyte Extract API 공통 유틸리티
+ */
+import { createTimeoutController } from './http.js';
+export function resolveZyteApiKey(apiKey) {
+    if (apiKey && apiKey.trim().length > 0) {
+        return apiKey;
+    }
+    /* c8 ignore start */
+    if (typeof process !== 'undefined' && process.env?.ZYTE_API_KEY) {
+        return process.env.ZYTE_API_KEY;
+    }
+    /* c8 ignore end */
+    throw new Error('ZYTE_API_KEY가 설정되지 않았습니다. .env 또는 Cloudflare Worker Secret을 확인해주세요.');
+}
+export function encodeBasicAuth(apiKey) {
+    if (typeof btoa === 'function') {
+        return btoa(`${apiKey}:`);
+    }
+    /* c8 ignore start */
+    if (typeof Buffer !== 'undefined') {
+        return Buffer.from(`${apiKey}:`).toString('base64');
+    }
+    /* c8 ignore end */
+    throw new Error('Basic 인증 인코딩을 지원하지 않는 런타임입니다.');
+}
+export function decodeBase64(value) {
+    if (typeof atob === 'function') {
+        const binary = atob(value);
+        const bytes = Uint8Array.from(binary, (char) => char.charCodeAt(0));
+        return new TextDecoder().decode(bytes);
+    }
+    /* c8 ignore start */
+    if (typeof Buffer !== 'undefined') {
+        return Buffer.from(value, 'base64').toString('utf8');
+    }
+    /* c8 ignore end */
+    throw new Error('Base64 디코딩을 지원하지 않는 런타임입니다.');
+}
+export async function requestByZyte(options) {
+    const { timeout = 15000, url, method = 'GET', headers = [], bodyText, apiKey } = options;
+    const auth = encodeBasicAuth(resolveZyteApiKey(apiKey));
+    const { controller, timeoutId } = createTimeoutController(timeout);
+    try {
+        const response = await fetch('https://api.zyte.com/v1/extract', {
+            method: 'POST',
+            headers: {
+                Authorization: `Basic ${auth}`,
+                'Content-Type': 'application/json',
+                Accept: 'application/json',
+            },
+            body: JSON.stringify({
+                url,
+                httpRequestMethod: method,
+                customHttpRequestHeaders: headers,
+                httpRequestText: bodyText,
+                httpResponseBody: true,
+            }),
+            signal: controller.signal,
+        });
+        const result = (await response.json());
+        if (!response.ok) {
+            throw new Error(`Zyte API 호출 실패: ${response.status} ${result.detail || result.title || ''}`.trim());
+        }
+        return result;
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+}
+export function decodeZyteHttpBody(result) {
+    if (!result.httpResponseBody) {
+        throw new Error('Zyte HTTP 응답 본문이 비어 있습니다.');
+    }
+    return JSON.parse(decodeBase64(result.httpResponseBody));
+}