@withwiz/toolkit 0.1.0

package/dist/chunk-TRBKJ7JT.js

@@ -0,0 +1,137 @@
+import {
+  __spreadValues
+} from "./chunk-ORMEWXMH.js";
+
+// src/utils/timezone.ts
+function getCurrentUTC() {
+  return /* @__PURE__ */ new Date();
+}
+function utcToLocal(utcDate, timezone) {
+  const date = new Date(utcDate);
+  if (timezone) {
+    return new Date(date.toLocaleString("en-US", { timeZone: timezone }));
+  }
+  return date;
+}
+function localToUTC(localDate) {
+  const date = new Date(localDate);
+  return new Date(date.getTime() - date.getTimezoneOffset() * 6e4);
+}
+function formatUserFriendlyDate(date, options) {
+  const dateObj = new Date(date);
+  const defaultOptions = __spreadValues({
+    year: "numeric",
+    month: "long",
+    day: "numeric",
+    hour: "2-digit",
+    minute: "2-digit",
+    timeZoneName: "short",
+    hour12: false
+  }, options);
+  return dateObj.toLocaleDateString(void 0, defaultOptions);
+}
+function formatSimpleDate(date) {
+  const dateObj = new Date(date);
+  return dateObj.toLocaleDateString(void 0, {
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  });
+}
+function formatSimpleTime(date) {
+  const dateObj = new Date(date);
+  return dateObj.toLocaleTimeString(void 0, {
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    hour12: false
+  });
+}
+function formatFullDateTime(date) {
+  const dateObj = new Date(date);
+  const dateStr = dateObj.toLocaleDateString(void 0, {
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  });
+  const timeStr = dateObj.toLocaleTimeString(void 0, {
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    hour12: false
+  });
+  return `${dateStr} ${timeStr}`;
+}
+function formatTableDateTime(date) {
+  const dateObj = new Date(date);
+  return {
+    date: dateObj.toLocaleDateString(void 0, {
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit"
+    }),
+    time: dateObj.toLocaleTimeString(void 0, {
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+      hour12: false
+    })
+  };
+}
+function getRelativeTime(date) {
+  const now = /* @__PURE__ */ new Date();
+  const targetDate = new Date(date);
+  const diffInSeconds = Math.floor(
+    (now.getTime() - targetDate.getTime()) / 1e3
+  );
+  if (diffInSeconds < 60) {
+    return "just now";
+  }
+  const diffInMinutes = Math.floor(diffInSeconds / 60);
+  if (diffInMinutes < 60) {
+    return `${diffInMinutes}m ago`;
+  }
+  const diffInHours = Math.floor(diffInMinutes / 60);
+  if (diffInHours < 24) {
+    return `${diffInHours}h ago`;
+  }
+  const diffInDays = Math.floor(diffInHours / 24);
+  if (diffInDays < 7) {
+    return `${diffInDays}d ago`;
+  }
+  const diffInWeeks = Math.floor(diffInDays / 7);
+  if (diffInWeeks < 4) {
+    return `${diffInWeeks}w ago`;
+  }
+  const diffInMonths = Math.floor(diffInDays / 30);
+  if (diffInMonths < 12) {
+    return `${diffInMonths}mo ago`;
+  }
+  const diffInYears = Math.floor(diffInDays / 365);
+  return `${diffInYears}y ago`;
+}
+function getUserTimezone() {
+  return Intl.DateTimeFormat().resolvedOptions().timeZone;
+}
+function getTimezoneOffset() {
+  return (/* @__PURE__ */ new Date()).getTimezoneOffset();
+}
+function toUTCISOString(date) {
+  const dateObj = new Date(date);
+  return dateObj.toISOString();
+}
+
+export {
+  getCurrentUTC,
+  utcToLocal,
+  localToUTC,
+  formatUserFriendlyDate,
+  formatSimpleDate,
+  formatSimpleTime,
+  formatFullDateTime,
+  formatTableDateTime,
+  getRelativeTime,
+  getUserTimezone,
+  getTimezoneOffset,
+  toUTCISOString
+};

package/dist/chunk-TXGNSECL.js

@@ -0,0 +1,84 @@
+import {
+  getENV,
+  isCacheEnabled
+} from "./chunk-I47QEDTX.js";
+
+// src/cache/cache-config.ts
+var getCacheConfig = {
+  // Analytics 캐시 설정
+  analytics: {
+    enabled: () => getENV().CACHE.ANALYTICS.ENABLED && isCacheEnabled(),
+    duration: () => getENV().CACHE.ANALYTICS.DURATION
+  },
+  // User 캐시 설정
+  user: {
+    enabled: () => getENV().CACHE.USER.ENABLED && isCacheEnabled(),
+    duration: () => getENV().CACHE.USER.DURATION
+  },
+  // GeoIP 캐시 설정
+  geoip: {
+    enabled: () => getENV().CACHE.GEOIP.ENABLED && isCacheEnabled(),
+    duration: () => getENV().CACHE.GEOIP.DURATION
+  },
+  // Settings 캐시 설정
+  settings: {
+    enabled: () => getENV().CACHE.SETTINGS.ENABLED && isCacheEnabled(),
+    duration: () => getENV().CACHE.SETTINGS.DURATION
+  },
+  // Reserved Words 캐시 설정
+  reservedWords: {
+    enabled: () => getENV().CACHE.RESERVED_WORDS.ENABLED && isCacheEnabled(),
+    duration: () => getENV().CACHE.RESERVED_WORDS.DURATION
+  },
+  // Alias 캐시 설정
+  alias: {
+    enabled: () => getENV().CACHE.ALIAS.ENABLED && isCacheEnabled(),
+    duration: () => getENV().CACHE.ALIAS.DURATION
+  },
+  // Community 캐시 설정
+  community: {
+    enabled: () => getENV().CACHE.COMMUNITY.ENABLED && isCacheEnabled(),
+    duration: () => getENV().CACHE.COMMUNITY.DURATION
+  },
+  // Link 캐시 설정
+  link: {
+    enabled: () => getENV().CACHE.LINK.ENABLED && isCacheEnabled(),
+    duration: () => getENV().CACHE.LINK.DURATION
+  },
+  // Rate Limiter 캐시 설정
+  rateLimit: {
+    enabled: () => getENV().CACHE.RATE_LIMIT.ENABLED && isCacheEnabled(),
+    duration: () => getENV().CACHE.RATE_LIMIT.DURATION
+  },
+  // URL Shortener Token 캐시 설정
+  urlToken: {
+    enabled: () => getENV().CACHE.URL_TOKEN.ENABLED && isCacheEnabled(),
+    duration: () => getENV().CACHE.URL_TOKEN.DURATION
+  },
+  // API Key 캐시 설정
+  apiKey: {
+    enabled: () => getENV().CACHE.API_KEY.ENABLED && isCacheEnabled(),
+    duration: () => getENV().CACHE.API_KEY.DURATION
+  },
+  // API Config 캐시 설정
+  apiConfig: {
+    enabled: () => getENV().CACHE.API_CONFIG.ENABLED && isCacheEnabled(),
+    duration: () => getENV().CACHE.API_CONFIG.DURATION
+  }
+};
+var getCacheTTL = {
+  settings: () => getCacheConfig.settings.duration(),
+  reservedWords: () => getCacheConfig.reservedWords.duration(),
+  alias: () => getCacheConfig.alias.duration(),
+  user: () => getCacheConfig.user.duration(),
+  analytics: () => getCacheConfig.analytics.duration(),
+  geoip: () => getCacheConfig.geoip.duration(),
+  community: () => getCacheConfig.community.duration(),
+  link: () => getCacheConfig.link.duration(),
+  default: () => getCacheConfig.analytics.duration()
+};
+
+export {
+  getCacheConfig,
+  getCacheTTL
+};

package/dist/chunk-TZAP5T4N.js

@@ -0,0 +1,188 @@
+import {
+  logger
+} from "./chunk-EZR55KV2.js";
+import {
+  __spreadValues
+} from "./chunk-ORMEWXMH.js";
+
+// src/geolocation/batch-processor.ts
+var BatchProcessor = class {
+  constructor(config) {
+    this.config = __spreadValues({
+      batchSize: 50,
+      delayBetweenBatches: 2e3,
+      maxConcurrentBatches: 3,
+      retryAttempts: 3,
+      timeout: 1e4
+    }, config);
+  }
+  /**
+   * 배치 처리 실행
+   */
+  async processBatch(items, processor, onProgress) {
+    const result = {
+      totalProcessed: 0,
+      successful: 0,
+      failed: 0,
+      skipped: 0,
+      errors: [],
+      processingTime: 0,
+      averageTimePerItem: 0
+    };
+    try {
+      logger.info(`Starting batch processing for ${items.length} items`);
+      for (let i = 0; i < items.length; i += this.config.batchSize) {
+        const batch = items.slice(i, i + this.config.batchSize);
+        try {
+          const batchResults = await processor(batch);
+          result.totalProcessed += batch.length;
+          result.successful += batchResults.length;
+          if (onProgress) {
+            onProgress(result.totalProcessed, items.length);
+          }
+          if (i + this.config.batchSize < items.length) {
+            await new Promise((resolve) => setTimeout(resolve, this.config.delayBetweenBatches));
+          }
+        } catch (error) {
+          logger.error(`Batch processing error for batch ${i}-${i + this.config.batchSize}`, { error });
+          result.errors.push(`Batch ${i}-${i + this.config.batchSize}: ${error}`);
+          result.failed += batch.length;
+        }
+      }
+      logger.info("Batch processing completed", result);
+      return result;
+    } catch (error) {
+      logger.error("Batch processing failed", { error });
+      result.errors.push(`Overall error: ${error}`);
+      return result;
+    }
+  }
+  /**
+   * 재시도 로직이 포함된 배치 처리
+   */
+  async processBatchWithRetry(items, processor, onProgress) {
+    const result = {
+      totalProcessed: 0,
+      successful: 0,
+      failed: 0,
+      skipped: 0,
+      errors: [],
+      processingTime: 0,
+      averageTimePerItem: 0
+    };
+    try {
+      logger.info(`Starting batch processing with retry for ${items.length} items`);
+      for (let i = 0; i < items.length; i += this.config.batchSize) {
+        const batch = items.slice(i, i + this.config.batchSize);
+        let batchResults = [];
+        let retryCount = 0;
+        while (retryCount < this.config.retryAttempts) {
+          try {
+            batchResults = await processor(batch);
+            break;
+          } catch (error) {
+            retryCount++;
+            logger.warn(`Batch processing attempt ${retryCount} failed for batch ${i}-${i + this.config.batchSize}`, { error });
+            if (retryCount >= this.config.retryAttempts) {
+              throw error;
+            }
+            await new Promise((resolve) => setTimeout(resolve, this.config.delayBetweenBatches * retryCount));
+          }
+        }
+        result.totalProcessed += batch.length;
+        result.successful += batchResults.length;
+        if (onProgress) {
+          onProgress(result.totalProcessed, items.length);
+        }
+        if (i + this.config.batchSize < items.length) {
+          await new Promise((resolve) => setTimeout(resolve, this.config.delayBetweenBatches));
+        }
+      }
+      logger.info("Batch processing with retry completed", result);
+      return result;
+    } catch (error) {
+      logger.error("Batch processing with retry failed", { error });
+      result.errors.push(`Overall error: ${error}`);
+      return result;
+    }
+  }
+  /**
+   * 동시 배치 처리 (병렬 처리)
+   */
+  async processBatchConcurrent(items, processor, onProgress) {
+    const result = {
+      totalProcessed: 0,
+      successful: 0,
+      failed: 0,
+      skipped: 0,
+      errors: [],
+      processingTime: 0,
+      averageTimePerItem: 0
+    };
+    try {
+      logger.info(`Starting concurrent batch processing for ${items.length} items`);
+      const batches = [];
+      for (let i = 0; i < items.length; i += this.config.batchSize) {
+        batches.push(items.slice(i, i + this.config.batchSize));
+      }
+      const concurrentBatches = [];
+      for (let i = 0; i < batches.length; i += this.config.maxConcurrentBatches) {
+        concurrentBatches.push(batches.slice(i, i + this.config.maxConcurrentBatches));
+      }
+      for (const batchGroup of concurrentBatches) {
+        const promises = batchGroup.map(async (batch, index) => {
+          try {
+            const batchResults2 = await processor(batch);
+            return { success: true, results: batchResults2, batchIndex: index };
+          } catch (error) {
+            logger.error(`Concurrent batch processing error for batch ${index}`, { error });
+            return { success: false, error, batchIndex: index };
+          }
+        });
+        const batchResults = await Promise.all(promises);
+        batchResults.forEach(({ success, results, error, batchIndex }) => {
+          const batch = batchGroup[batchIndex];
+          result.totalProcessed += batch.length;
+          if (success && results) {
+            result.successful += results.length;
+          } else {
+            result.failed += batch.length;
+            result.errors.push(`Concurrent batch ${batchIndex}: ${error}`);
+          }
+        });
+        if (onProgress) {
+          onProgress(result.totalProcessed, items.length);
+        }
+        if (concurrentBatches.indexOf(batchGroup) < concurrentBatches.length - 1) {
+          await new Promise((resolve) => setTimeout(resolve, this.config.delayBetweenBatches));
+        }
+      }
+      logger.info("Concurrent batch processing completed", result);
+      return result;
+    } catch (error) {
+      logger.error("Concurrent batch processing failed", { error });
+      result.errors.push(`Overall error: ${error}`);
+      return result;
+    }
+  }
+  /**
+   * 설정 업데이트
+   */
+  updateConfig(newConfig) {
+    this.config = __spreadValues(__spreadValues({}, this.config), newConfig);
+  }
+  /**
+   * 현재 설정 조회
+   */
+  getConfig() {
+    return __spreadValues({}, this.config);
+  }
+};
+function createBatchProcessor(config) {
+  return new BatchProcessor(config);
+}
+
+export {
+  BatchProcessor,
+  createBatchProcessor
+};

package/dist/chunk-UCYQNHST.js

@@ -0,0 +1,24 @@
+import {
+  cn
+} from "./chunk-62FLBG6B.js";
+
+// src/components/ui/Badge.tsx
+import { jsx } from "react/jsx-runtime";
+function Badge({
+  children,
+  variant = "default",
+  className
+}) {
+  const baseClasses = "inline-flex items-center rounded-full border px-2.5 py-0.5 text-xs font-semibold transition-colors focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2";
+  const variantClasses = {
+    default: "border-transparent bg-primary text-primary-foreground hover:bg-primary/80",
+    secondary: "border-transparent bg-secondary text-secondary-foreground hover:bg-secondary/80",
+    destructive: "border-transparent bg-destructive text-destructive-foreground hover:bg-destructive/80",
+    outline: "text-foreground"
+  };
+  return /* @__PURE__ */ jsx("div", { className: cn(baseClasses, variantClasses[variant], className), children });
+}
+
+export {
+  Badge
+};

package/dist/chunk-UXQRU3EM.js

@@ -0,0 +1,167 @@
+import {
+  AppError
+} from "./chunk-MLGO3HLS.js";
+import {
+  ERROR_CODES
+} from "./chunk-Y3OTJH2S.js";
+import {
+  JWTManager
+} from "./chunk-T3LJYAMO.js";
+import {
+  logger
+} from "./chunk-EZR55KV2.js";
+
+// src/middleware/auth.ts
+function setAccessTokenBlacklistChecker(checker) {
+  globalThis.__accessTokenBlacklistChecker = checker;
+  logger.info(
+    "[Auth Middleware] Access Token blacklist checker configured"
+  );
+}
+function getAccessTokenChecker() {
+  var _a;
+  return (_a = globalThis.__accessTokenBlacklistChecker) != null ? _a : null;
+}
+var _jwtManager = null;
+var _jwtWarningLogged = false;
+function getJWTManager() {
+  if (!_jwtManager) {
+    const secret = process.env.JWT_SECRET;
+    if (!secret) {
+      if (!_jwtWarningLogged) {
+        logger.warn(
+          "[Auth Middleware] JWT_SECRET not configured. Authentication is DISABLED.\nProtected routes will fail. Set JWT_SECRET environment variable to enable auth."
+        );
+        _jwtWarningLogged = true;
+      }
+      return null;
+    }
+    if (secret.length < 32) {
+      logger.error(
+        "[Auth Middleware] JWT_SECRET must be at least 32 characters long"
+      );
+      return null;
+    }
+    _jwtManager = new JWTManager(
+      {
+        secret,
+        accessTokenExpiry: process.env.JWT_EXPIRES_IN || "7d",
+        refreshTokenExpiry: process.env.JWT_REFRESH_TOKEN_EXPIRES_IN || "30d",
+        algorithm: "HS256"
+      },
+      // Winston logger for middleware
+      {
+        debug: (msg, meta) => logger.debug(`[Auth] ${msg}`, meta),
+        info: (msg, meta) => logger.info(`[Auth] ${msg}`, meta),
+        warn: (msg, meta) => logger.warn(`[Auth] ${msg}`, meta),
+        error: (msg, meta) => logger.error(`[Auth] ${msg}`, meta)
+      }
+    );
+    logger.info(
+      `[Auth Middleware] \u2705 Initialized - Access: ${process.env.JWT_EXPIRES_IN || "7d"}, Refresh: ${process.env.JWT_REFRESH_TOKEN_EXPIRES_IN || "30d"}`
+    );
+  }
+  return _jwtManager;
+}
+function initializeAuthMiddleware() {
+  const jwtManager = getJWTManager();
+  return jwtManager !== null;
+}
+var authMiddleware = async (context, next) => {
+  var _a, _b;
+  try {
+    const jwtManager = getJWTManager();
+    if (!jwtManager) {
+      logger.error(
+        "[Auth Middleware] Cannot authenticate - JWT_SECRET not configured"
+      );
+      throw new AppError(
+        ERROR_CODES.UNAUTHORIZED.code,
+        "Authentication not configured. Contact administrator."
+      );
+    }
+    const authHeader = context.request.headers.get("authorization");
+    const token = jwtManager.extractTokenFromHeader(authHeader);
+    if (!token) {
+      throw new AppError(ERROR_CODES.UNAUTHORIZED.code);
+    }
+    const tokenChecker = getAccessTokenChecker();
+    if (tokenChecker) {
+      const isRevoked = await tokenChecker.isAccessTokenRevoked(token);
+      if (isRevoked) {
+        logger.debug(
+          "[Auth Middleware] Access token is revoked (blacklisted)"
+        );
+        throw new AppError(
+          ERROR_CODES.INVALID_TOKEN.code,
+          "Token has been revoked"
+        );
+      }
+    }
+    const payload = await jwtManager.verifyAccessToken(token);
+    context.user = {
+      id: payload.userId,
+      email: (_a = payload.email) != null ? _a : "",
+      name: void 0,
+      // 필요시 DB에서 조회
+      role: payload.role === "ADMIN" ? "ADMIN" : "USER"
+    };
+  } catch (error) {
+    if (error instanceof AppError) {
+      throw error;
+    }
+    if (error.code === "TOKEN_EXPIRED" || ((_b = error.message) == null ? void 0 : _b.includes("expired"))) {
+      throw new AppError(ERROR_CODES.TOKEN_EXPIRED.code, error.message);
+    }
+    throw new AppError(
+      ERROR_CODES.INVALID_TOKEN.code,
+      error.message || "Invalid token"
+    );
+  }
+  return await next();
+};
+var optionalAuthMiddleware = async (context, next) => {
+  var _a;
+  try {
+    const jwtManager = getJWTManager();
+    if (jwtManager) {
+      const authHeader = context.request.headers.get("authorization");
+      const token = jwtManager.extractTokenFromHeader(authHeader);
+      if (token) {
+        const tokenChecker = getAccessTokenChecker();
+        let isRevoked = false;
+        if (tokenChecker) {
+          isRevoked = await tokenChecker.isAccessTokenRevoked(token);
+        }
+        if (!isRevoked) {
+          const payload = await jwtManager.verifyAccessToken(token);
+          context.user = {
+            id: payload.userId,
+            email: (_a = payload.email) != null ? _a : "",
+            name: void 0,
+            role: payload.role === "ADMIN" ? "ADMIN" : "USER"
+          };
+        }
+      }
+    }
+  } catch (e) {
+  }
+  return await next();
+};
+var adminMiddleware = async (context, next) => {
+  if (!context.user) {
+    throw new AppError(ERROR_CODES.UNAUTHORIZED.code);
+  }
+  if (context.user.role !== "ADMIN") {
+    throw new AppError(ERROR_CODES.FORBIDDEN.code);
+  }
+  return await next();
+};
+
+export {
+  setAccessTokenBlacklistChecker,
+  initializeAuthMiddleware,
+  authMiddleware,
+  optionalAuthMiddleware,
+  adminMiddleware
+};