@withwiz/toolkit 0.1.0

package/dist/chunk-7VJNLGAS.js

@@ -0,0 +1,110 @@
+// src/error/recovery/circuit-breaker.ts
+var ECircuitState = /* @__PURE__ */ ((ECircuitState2) => {
+  ECircuitState2["CLOSED"] = "closed";
+  ECircuitState2["OPEN"] = "open";
+  ECircuitState2["HALF_OPEN"] = "half-open";
+  return ECircuitState2;
+})(ECircuitState || {});
+var CircuitBreaker = class {
+  constructor(options = {}) {
+    this.state = "closed" /* CLOSED */;
+    this.failureCount = 0;
+    this.successCount = 0;
+    this.nextAttemptTime = 0;
+    this.options = {
+      failureThreshold: options.failureThreshold || 5,
+      successThreshold: options.successThreshold || 2,
+      timeout: options.timeout || 6e4,
+      onStateChange: options.onStateChange || (() => {
+      }),
+      onError: options.onError || (() => {
+      })
+    };
+  }
+  /**
+   * 함수 실행
+   */
+  async execute(fn) {
+    if (this.state === "open" /* OPEN */) {
+      if (Date.now() < this.nextAttemptTime) {
+        throw new Error("Circuit breaker is OPEN");
+      }
+      this.setState("half-open" /* HALF_OPEN */);
+    }
+    try {
+      const result = await fn();
+      this.onSuccess();
+      return result;
+    } catch (error) {
+      this.onFailure();
+      this.options.onError(error);
+      throw error;
+    }
+  }
+  /**
+   * 성공 처리
+   */
+  onSuccess() {
+    this.failureCount = 0;
+    if (this.state === "half-open" /* HALF_OPEN */) {
+      this.successCount++;
+      if (this.successCount >= this.options.successThreshold) {
+        this.setState("closed" /* CLOSED */);
+        this.successCount = 0;
+      }
+    }
+  }
+  /**
+   * 실패 처리
+   */
+  onFailure() {
+    this.failureCount++;
+    this.successCount = 0;
+    if (this.failureCount >= this.options.failureThreshold) {
+      this.setState("open" /* OPEN */);
+      this.nextAttemptTime = Date.now() + this.options.timeout;
+    }
+  }
+  /**
+   * 상태 변경
+   */
+  setState(newState) {
+    const oldState = this.state;
+    if (oldState !== newState) {
+      this.state = newState;
+      this.options.onStateChange(oldState, newState);
+      console.log(`[CircuitBreaker] State changed: ${oldState} -> ${newState}`);
+    }
+  }
+  /**
+   * 현재 상태 조회
+   */
+  getState() {
+    return this.state;
+  }
+  /**
+   * 상태 초기화
+   */
+  reset() {
+    this.setState("closed" /* CLOSED */);
+    this.failureCount = 0;
+    this.successCount = 0;
+    this.nextAttemptTime = 0;
+  }
+  /**
+   * 메트릭 조회
+   */
+  getMetrics() {
+    return {
+      state: this.state,
+      failureCount: this.failureCount,
+      successCount: this.successCount,
+      nextAttemptTime: this.nextAttemptTime
+    };
+  }
+};
+
+export {
+  ECircuitState,
+  CircuitBreaker
+};

package/dist/chunk-A6EAAWMK.js

@@ -0,0 +1,50 @@
+// src/error/recovery/retry.ts
+function defaultShouldRetry(error) {
+  if (error instanceof Error) {
+    const message = error.message.toLowerCase();
+    return message.includes("network") || message.includes("timeout") || message.includes("econnrefused") || message.includes("enotfound") || message.includes("503") || message.includes("504");
+  }
+  return false;
+}
+async function withRetry(fn, options = {}) {
+  const {
+    maxAttempts = 3,
+    delay = 1e3,
+    exponentialBackoff = true,
+    backoffMultiplier = 2,
+    maxDelay = 3e4,
+    shouldRetry = defaultShouldRetry,
+    onRetry
+  } = options;
+  let lastError;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt === maxAttempts) {
+        throw error;
+      }
+      if (!shouldRetry(error, attempt)) {
+        throw error;
+      }
+      onRetry == null ? void 0 : onRetry(error, attempt);
+      let currentDelay = delay;
+      if (exponentialBackoff) {
+        currentDelay = Math.min(
+          delay * Math.pow(backoffMultiplier, attempt - 1),
+          maxDelay
+        );
+      }
+      await sleep(currentDelay);
+    }
+  }
+  throw lastError;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export {
+  withRetry
+};

package/dist/chunk-AHDPGRXS.js

@@ -0,0 +1,51 @@
+// src/geolocation/providers/base-provider.ts
+function truncateString(str, maxLength) {
+  if (!str) return null;
+  return str.length > maxLength ? str.substring(0, maxLength) : str;
+}
+var BaseGeoIPProvider = class {
+  isAvailable() {
+    return true;
+  }
+  getRateLimit() {
+    return this.rateLimit;
+  }
+  getTimeout() {
+    return this.timeout;
+  }
+  /**
+   * IP 주소로 GeoIP 데이터 조회
+   * @param ip - IP 주소
+   * @returns GeoIP 데이터 또는 null
+   */
+  async fetchGeoData(ip) {
+    const serviceUrl = this.url(ip);
+    if (!serviceUrl) return null;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(serviceUrl, {
+        headers: {
+          "User-Agent": "GeoIP-Service/1.0"
+        },
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) return null;
+      const data = await response.json();
+      const geoData = this.parseResponse(data);
+      if (geoData) {
+        geoData.ipAddress = ip;
+      }
+      return geoData;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      return null;
+    }
+  }
+};
+
+export {
+  truncateString,
+  BaseGeoIPProvider
+};

package/dist/chunk-AIH3F7JV.js

@@ -0,0 +1,76 @@
+// src/auth/errors/index.ts
+var AuthError = class _AuthError extends Error {
+  constructor(message, code, statusCode = 400) {
+    super(message);
+    this.code = code;
+    this.statusCode = statusCode;
+    this.name = "AuthError";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _AuthError);
+    }
+  }
+};
+var JWTError = class extends AuthError {
+  constructor(message, code = "JWT_ERROR") {
+    super(message, code, 401);
+    this.name = "JWTError";
+  }
+};
+var OAuthError = class extends AuthError {
+  constructor(message, code = "OAUTH_ERROR") {
+    super(message, code, 400);
+    this.name = "OAuthError";
+  }
+};
+var EmailError = class extends AuthError {
+  constructor(message, code = "EMAIL_ERROR") {
+    super(message, code, 500);
+    this.name = "EmailError";
+  }
+};
+var PasswordError = class extends AuthError {
+  constructor(message, code = "PASSWORD_ERROR") {
+    super(message, code, 400);
+    this.name = "PasswordError";
+  }
+};
+var AUTH_ERROR_CODES = {
+  // JWT Errors
+  TOKEN_EXPIRED: "TOKEN_EXPIRED",
+  TOKEN_INVALID: "TOKEN_INVALID",
+  TOKEN_CREATION_FAILED: "TOKEN_CREATION_FAILED",
+  TOKEN_VERIFICATION_FAILED: "TOKEN_VERIFICATION_FAILED",
+  REFRESH_TOKEN_EXPIRED: "REFRESH_TOKEN_EXPIRED",
+  INVALID_PAYLOAD: "INVALID_PAYLOAD",
+  // OAuth Errors
+  OAUTH_PROVIDER_NOT_CONFIGURED: "OAUTH_PROVIDER_NOT_CONFIGURED",
+  OAUTH_TOKEN_EXCHANGE_FAILED: "OAUTH_TOKEN_EXCHANGE_FAILED",
+  OAUTH_USER_INFO_FAILED: "OAUTH_USER_INFO_FAILED",
+  // Password Errors
+  PASSWORD_TOO_SHORT: "PASSWORD_TOO_SHORT",
+  PASSWORD_TOO_LONG: "PASSWORD_TOO_LONG",
+  PASSWORD_MISSING_NUMBER: "PASSWORD_MISSING_NUMBER",
+  PASSWORD_MISSING_UPPERCASE: "PASSWORD_MISSING_UPPERCASE",
+  PASSWORD_MISSING_LOWERCASE: "PASSWORD_MISSING_LOWERCASE",
+  PASSWORD_MISSING_SPECIAL_CHAR: "PASSWORD_MISSING_SPECIAL_CHAR",
+  PASSWORD_HASH_FAILED: "PASSWORD_HASH_FAILED",
+  PASSWORD_VERIFY_FAILED: "PASSWORD_VERIFY_FAILED",
+  // Email Errors
+  EMAIL_SEND_FAILED: "EMAIL_SEND_FAILED",
+  EMAIL_TOKEN_INVALID: "EMAIL_TOKEN_INVALID",
+  EMAIL_TOKEN_EXPIRED: "EMAIL_TOKEN_EXPIRED",
+  // Generic Errors
+  INVALID_CREDENTIALS: "INVALID_CREDENTIALS",
+  USER_NOT_FOUND: "USER_NOT_FOUND",
+  EMAIL_ALREADY_EXISTS: "EMAIL_ALREADY_EXISTS",
+  UNAUTHORIZED: "UNAUTHORIZED"
+};
+
+export {
+  AuthError,
+  JWTError,
+  OAuthError,
+  EmailError,
+  PasswordError,
+  AUTH_ERROR_CODES
+};

package/dist/chunk-AIHQBQ3E.js

@@ -0,0 +1,109 @@
+import {
+  HybridCacheManager
+} from "./chunk-HV3DGSSH.js";
+import {
+  InMemoryCacheManager
+} from "./chunk-Z4D4CMDA.js";
+import {
+  NoopCacheManager
+} from "./chunk-Q7IP4JMW.js";
+import {
+  RedisCacheManager
+} from "./chunk-GL2NANFH.js";
+import {
+  getCacheConfig
+} from "./chunk-TXGNSECL.js";
+import {
+  isRedisAvailableNow,
+  isRedisGloballyDisabled
+} from "./chunk-6LTZCXNC.js";
+import {
+  getENV,
+  isCacheEnabled
+} from "./chunk-I47QEDTX.js";
+import {
+  logger
+} from "./chunk-EZR55KV2.js";
+
+// src/cache/cache-factory.ts
+function getInMemoryConfig() {
+  const ENV = getENV();
+  return {
+    maxSize: ENV.CACHE.INMEMORY.MAX_SIZE,
+    maxMemoryMB: ENV.CACHE.INMEMORY.MAX_MB,
+    evictionPolicy: ENV.CACHE.INMEMORY.EVICTION,
+    cleanupInterval: ENV.CACHE.INMEMORY.CLEANUP_INTERVAL
+  };
+}
+function getEffectiveCacheBackend() {
+  var _a, _b, _c, _d;
+  const cache2 = getENV().CACHE;
+  const redisEnabled = (_b = (_a = cache2.REDIS) == null ? void 0 : _a.ENABLED) != null ? _b : true;
+  const inmemoryEnabled = (_d = (_c = cache2.INMEMORY) == null ? void 0 : _c.ENABLED) != null ? _d : true;
+  if (isRedisGloballyDisabled()) {
+    if (inmemoryEnabled) {
+      return "memory";
+    }
+    return "none";
+  }
+  if (redisEnabled && inmemoryEnabled) {
+    return "hybrid";
+  } else if (redisEnabled && !inmemoryEnabled) {
+    return "redis";
+  } else if (!redisEnabled && inmemoryEnabled) {
+    return "memory";
+  } else {
+    return "none";
+  }
+}
+var _noBackendWarningLogged = false;
+function getCacheManager(prefix) {
+  var _a, _b, _c, _d;
+  const cacheConfig = getCacheConfig[prefix];
+  if (cacheConfig && !cacheConfig.enabled()) {
+    return new NoopCacheManager(prefix);
+  }
+  if (!isCacheEnabled()) {
+    return new NoopCacheManager(prefix);
+  }
+  const effectiveBackend = getEffectiveCacheBackend();
+  const inmemoryConfig = getInMemoryConfig();
+  if (effectiveBackend === "none") {
+    if (!_noBackendWarningLogged) {
+      logger.warn(
+        "[Cache] CACHE_ENABLED=true\uC774\uC9C0\uB9CC \uC0AC\uC6A9 \uAC00\uB2A5\uD55C \uBC31\uC5D4\uB4DC\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4. \uCE90\uC2DC\uAC00 \uC2E4\uC9C8\uC801\uC73C\uB85C \uBE44\uD65C\uC131\uD654\uB429\uB2C8\uB2E4. CACHE_REDIS_ENABLED \uB610\uB294 CACHE_INMEMORY_ENABLED\uB97C true\uB85C \uC124\uC815\uD558\uC138\uC694.",
+        {
+          CACHE_ENABLED: true,
+          CACHE_REDIS_ENABLED: (_b = (_a = getENV().CACHE.REDIS) == null ? void 0 : _a.ENABLED) != null ? _b : false,
+          CACHE_INMEMORY_ENABLED: (_d = (_c = getENV().CACHE.INMEMORY) == null ? void 0 : _c.ENABLED) != null ? _d : false
+        }
+      );
+      _noBackendWarningLogged = true;
+    }
+    return new NoopCacheManager(prefix);
+  }
+  switch (effectiveBackend) {
+    case "memory":
+      return InMemoryCacheManager.getInstance(prefix, inmemoryConfig);
+    case "hybrid":
+      return HybridCacheManager.getInstance(prefix, {
+        backend: "hybrid",
+        redisManager: isRedisAvailableNow() ? RedisCacheManager.getInstance(prefix) : null,
+        inmemoryConfig,
+        fallbackOnRedisError: true,
+        writeToMemory: true
+      });
+    case "redis":
+    default:
+      return RedisCacheManager.getInstance(prefix);
+  }
+}
+var cache = getCacheManager("default");
+var geoCache = getCacheManager("geo");
+
+export {
+  getEffectiveCacheBackend,
+  getCacheManager,
+  cache,
+  geoCache
+};

package/dist/chunk-BKGVSC6S.js

@@ -0,0 +1,152 @@
+import {
+  logger
+} from "./chunk-EZR55KV2.js";
+import {
+  __spreadValues
+} from "./chunk-ORMEWXMH.js";
+
+// src/utils/csv-export.ts
+import { format as dateFnsFormat } from "date-fns";
+import { NextResponse } from "next/server";
+function escapeCsvField(value) {
+  if (value === null || value === void 0) {
+    return '""';
+  }
+  const str = String(value);
+  return `"${str.replace(/"/g, '""')}"`;
+}
+function getColumnValue(row, column) {
+  const value = typeof column.accessor === "function" ? column.accessor(row) : row[column.accessor];
+  return escapeCsvField(value);
+}
+function rowToCsv(row, columns) {
+  return columns.map((col) => getColumnValue(row, col)).join(",");
+}
+function createCsvHeader(columns) {
+  return columns.map((col) => escapeCsvField(col.header)).join(",");
+}
+function createSimpleCsvResponse(data, options) {
+  const { filename, columns, includeBom = true, logContext } = options;
+  try {
+    const header = createCsvHeader(columns);
+    const rows = data.map((row) => rowToCsv(row, columns));
+    const csv = [header, ...rows].join("\r\n");
+    const content = includeBom ? "\uFEFF" + csv : csv;
+    logger.info("CSV export completed", __spreadValues({
+      filename,
+      rowCount: data.length
+    }, logContext));
+    return new NextResponse(content, {
+      headers: {
+        "Content-Type": "text/csv; charset=utf-8",
+        "Content-Disposition": `attachment; filename="${filename}_${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.csv"`
+      }
+    });
+  } catch (error) {
+    logger.error("CSV export error", __spreadValues({ error, filename }, logContext));
+    throw error;
+  }
+}
+function createStreamingCsvResponse(options) {
+  const {
+    filename,
+    columns,
+    batchSize = 1e3,
+    fetcher,
+    includeBom = true,
+    logContext
+  } = options;
+  const stream = new TransformStream();
+  const writer = stream.writable.getWriter();
+  const encoder = new TextEncoder();
+  (async () => {
+    try {
+      const header = createCsvHeader(columns);
+      const headerContent = includeBom ? "\uFEFF" + header + "\r\n" : header + "\r\n";
+      await writer.write(encoder.encode(headerContent));
+      let cursor;
+      let totalCount = 0;
+      let batchCount = 0;
+      while (true) {
+        const { data, nextCursor } = await fetcher(cursor);
+        if (data.length === 0) break;
+        const csvRows = data.map((row) => rowToCsv(row, columns));
+        await writer.write(encoder.encode(csvRows.join("\r\n") + "\r\n"));
+        totalCount += data.length;
+        batchCount++;
+        cursor = nextCursor;
+        logger.debug("Export batch processed", __spreadValues({
+          filename,
+          batchNumber: batchCount,
+          batchSize: data.length,
+          totalProcessed: totalCount
+        }, logContext));
+        if (data.length < batchSize || !nextCursor) break;
+      }
+      logger.info("Streaming CSV export completed", __spreadValues({
+        filename,
+        totalCount,
+        batchCount
+      }, logContext));
+      await writer.close();
+    } catch (error) {
+      logger.error("Streaming CSV export error", __spreadValues({ error, filename }, logContext));
+      await writer.abort(error);
+    }
+  })();
+  return new NextResponse(stream.readable, {
+    headers: {
+      "Content-Type": "text/csv; charset=utf-8",
+      "Content-Disposition": `attachment; filename="${filename}_${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.csv"`,
+      "Transfer-Encoding": "chunked"
+    }
+  });
+}
+var dateFormatter = {
+  /** ISO 형식 (YYYY-MM-DD) */
+  iso: (date) => {
+    if (!date) return "";
+    return date.toISOString().split("T")[0];
+  },
+  /** 한국어 형식 */
+  korean: (date) => {
+    if (!date) return "";
+    return date.toLocaleString("ko-KR");
+  },
+  /** 영어 형식 */
+  english: (date) => {
+    if (!date) return "";
+    return date.toLocaleString("en-US");
+  },
+  /** 커스텀 형식 (date-fns 사용) */
+  custom: (date, formatStr) => {
+    if (!date) return "";
+    try {
+      return dateFnsFormat(date, formatStr);
+    } catch (e) {
+      return date.toISOString();
+    }
+  }
+};
+var boolFormatter = {
+  /** Active/Inactive */
+  activeInactive: (value) => value ? "Active" : "Inactive",
+  /** Yes/No */
+  yesNo: (value) => value ? "Yes" : "No",
+  /** 1/0 */
+  numeric: (value) => value ? "1" : "0",
+  /** Verified/Not Verified */
+  verified: (value) => value ? "Verified" : "Not Verified",
+  /** 한국어 */
+  korean: (value) => value ? "\uC608" : "\uC544\uB2C8\uC624"
+};
+
+export {
+  escapeCsvField,
+  rowToCsv,
+  createCsvHeader,
+  createSimpleCsvResponse,
+  createStreamingCsvResponse,
+  dateFormatter,
+  boolFormatter
+};

package/dist/chunk-DEEJBDJE.js

@@ -0,0 +1,47 @@
+import {
+  BaseGeoIPProvider,
+  truncateString
+} from "./chunk-AHDPGRXS.js";
+
+// src/geolocation/providers/ip-api-provider.ts
+var IPApiProvider = class extends BaseGeoIPProvider {
+  constructor() {
+    super(...arguments);
+    this.name = "ip-api.com";
+    this.rateLimit = 45;
+    // 분당 45회 요청 제한
+    this.timeout = 5e3;
+  }
+  // 5초 타임아웃
+  url(ip) {
+    return `http://ip-api.com/json/${ip}?fields=status,message,country,countryCode,region,regionName,city,lat,lon,timezone,isp,org,as,proxy,hosting`;
+  }
+  parseResponse(data) {
+    if (data.status === "success") {
+      return {
+        ipAddress: "",
+        // IP는 별도로 설정
+        country: truncateString(data.countryCode, 2) || void 0,
+        countryName: truncateString(data.country, 100) || void 0,
+        region: truncateString(data.regionName, 100) || void 0,
+        regionCode: truncateString(data.region, 10) || void 0,
+        city: truncateString(data.city, 100) || void 0,
+        latitude: data.lat,
+        longitude: data.lon,
+        timezone: truncateString(data.timezone, 50) || void 0,
+        isp: truncateString(data.isp, 500) || void 0,
+        organization: truncateString(data.org, 500) || void 0,
+        asn: truncateString(data.as, 50) || void 0,
+        isPrivate: false,
+        isProxy: data.proxy || false,
+        accuracy: 1e3,
+        lastUpdated: /* @__PURE__ */ new Date()
+      };
+    }
+    return null;
+  }
+};
+
+export {
+  IPApiProvider
+};

package/dist/chunk-DH2ZHGW2.js

@@ -0,0 +1,53 @@
+import {
+  BaseGeoIPProvider,
+  truncateString
+} from "./chunk-AHDPGRXS.js";
+
+// src/geolocation/providers/ipgeolocation-provider.ts
+var IPGeolocationProvider = class extends BaseGeoIPProvider {
+  constructor() {
+    super(...arguments);
+    this.name = "ipgeolocation.io";
+    this.rateLimit = 1e4;
+    // 분당 10000회 요청 제한 (유료 플랜 기준)
+    this.timeout = 3e3;
+  }
+  // 3초 타임아웃
+  url(ip) {
+    const apiKey = process.env.IPGEOLOCATION_API_KEY;
+    if (!apiKey) return "";
+    return `https://api.ipgeolocation.io/ipgeo?apiKey=${apiKey}&ip=${ip}`;
+  }
+  parseResponse(data) {
+    if (data.country) {
+      return {
+        ipAddress: "",
+        // IP는 별도로 설정
+        country: truncateString(data.countryCode || data.country, 2) || void 0,
+        countryName: truncateString(data.country, 100) || void 0,
+        region: truncateString(data.regionName || data.region, 100) || void 0,
+        regionCode: truncateString(data.region, 10) || void 0,
+        city: truncateString(data.city, 100) || void 0,
+        latitude: data.latitude || data.lat,
+        longitude: data.longitude || data.lon,
+        timezone: truncateString(data.timezone, 50) || void 0,
+        isp: truncateString(data.isp || data.organization, 500) || void 0,
+        organization: truncateString(data.organization || data.org, 500) || void 0,
+        asn: truncateString(data.asn || data.as, 50) || void 0,
+        isPrivate: false,
+        isProxy: false,
+        accuracy: 100,
+        // 더 높은 정확도
+        lastUpdated: /* @__PURE__ */ new Date()
+      };
+    }
+    return null;
+  }
+  isAvailable() {
+    return !!process.env.IPGEOLOCATION_API_KEY;
+  }
+};
+
+export {
+  IPGeolocationProvider
+};