@withwiz/toolkit 0.1.0

package/dist/chunk-SLG26KHZ.js

@@ -0,0 +1,101 @@
+import {
+  MiddlewareChain
+} from "./chunk-4ODT3Q4A.js";
+import {
+  rateLimitMiddleware
+} from "./chunk-H5I5GWAA.js";
+import {
+  responseLoggerMiddleware
+} from "./chunk-KAWVMIRJ.js";
+import {
+  securityMiddleware
+} from "./chunk-WSQMXMTL.js";
+import {
+  adminMiddleware,
+  authMiddleware,
+  optionalAuthMiddleware
+} from "./chunk-UXQRU3EM.js";
+import {
+  corsMiddleware
+} from "./chunk-FOKAATUQ.js";
+import {
+  errorHandlerMiddleware
+} from "./chunk-TMVS4F7E.js";
+import {
+  initRequestMiddleware
+} from "./chunk-62Q7DN5G.js";
+
+// src/middleware/wrappers.ts
+function withPublicApi(handler) {
+  const chain = new MiddlewareChain().use(errorHandlerMiddleware).use(securityMiddleware).use(corsMiddleware).use(initRequestMiddleware).use(rateLimitMiddleware.api).use(responseLoggerMiddleware);
+  return async (request, props) => {
+    const context = {
+      request,
+      locale: "ko",
+      requestId: "",
+      startTime: Date.now(),
+      metadata: {}
+    };
+    return await chain.execute(context, handler, props);
+  };
+}
+function withAuthApi(handler) {
+  const chain = new MiddlewareChain().use(errorHandlerMiddleware).use(securityMiddleware).use(corsMiddleware).use(initRequestMiddleware).use(authMiddleware).use(rateLimitMiddleware.api).use(responseLoggerMiddleware);
+  return async (request, props) => {
+    const context = {
+      request,
+      locale: "ko",
+      requestId: "",
+      startTime: Date.now(),
+      metadata: {}
+    };
+    return await chain.execute(context, handler, props);
+  };
+}
+function withAdminApi(handler) {
+  const chain = new MiddlewareChain().use(errorHandlerMiddleware).use(securityMiddleware).use(corsMiddleware).use(initRequestMiddleware).use(authMiddleware).use(adminMiddleware).use(rateLimitMiddleware.admin).use(responseLoggerMiddleware);
+  return async (request, props) => {
+    const context = {
+      request,
+      locale: "ko",
+      requestId: "",
+      startTime: Date.now(),
+      metadata: {}
+    };
+    return await chain.execute(context, handler, props);
+  };
+}
+function withOptionalAuthApi(handler) {
+  const chain = new MiddlewareChain().use(errorHandlerMiddleware).use(securityMiddleware).use(corsMiddleware).use(initRequestMiddleware).use(optionalAuthMiddleware).use(rateLimitMiddleware.api).use(responseLoggerMiddleware);
+  return async (request, props) => {
+    const context = {
+      request,
+      locale: "ko",
+      requestId: "",
+      startTime: Date.now(),
+      metadata: {}
+    };
+    return await chain.execute(context, handler, props);
+  };
+}
+function withCustomApi(handler, configureChain) {
+  const chain = configureChain(new MiddlewareChain());
+  return async (request, props) => {
+    const context = {
+      request,
+      locale: "ko",
+      requestId: "",
+      startTime: Date.now(),
+      metadata: {}
+    };
+    return await chain.execute(context, handler, props);
+  };
+}
+
+export {
+  withPublicApi,
+  withAuthApi,
+  withAdminApi,
+  withOptionalAuthApi,
+  withCustomApi
+};

package/dist/chunk-SR65BF6X.js

@@ -0,0 +1,82 @@
+import {
+  __spreadValues
+} from "./chunk-ORMEWXMH.js";
+
+// src/utils/sanitizer.ts
+function sanitizeHtml(input) {
+  if (!input || typeof input !== "string") {
+    return "";
+  }
+  return input.replace(/<[^>]*>/g, "").replace(/&lt;/gi, "<").replace(/&gt;/gi, ">").replace(/<[^>]*>/g, "").replace(/&amp;/gi, "&").replace(/&quot;/gi, '"').replace(/&#x27;/gi, "'").replace(/&#x2F;/gi, "/").trim();
+}
+function removeEventHandlers(input) {
+  if (!input || typeof input !== "string") {
+    return "";
+  }
+  return input.replace(/\bon\w+\s*=\s*["'][^"']*["']/gi, "");
+}
+function sanitizeUrl(url) {
+  if (!url || typeof url !== "string") {
+    return "";
+  }
+  const trimmedUrl = url.trim().toLowerCase();
+  const dangerousProtocols = [
+    "javascript:",
+    "vbscript:",
+    "data:text/html",
+    "data:application"
+  ];
+  for (const protocol of dangerousProtocols) {
+    if (trimmedUrl.startsWith(protocol)) {
+      return "";
+    }
+  }
+  return url.trim();
+}
+function sanitizeInput(input) {
+  if (!input || typeof input !== "string") {
+    return "";
+  }
+  let result = input;
+  result = sanitizeHtml(result);
+  result = removeEventHandlers(result);
+  result = result.replace(/\s+/g, " ");
+  result = result.trim();
+  return result;
+}
+function sanitizeArray(arr) {
+  if (!Array.isArray(arr)) {
+    return [];
+  }
+  return arr.filter((item) => typeof item === "string").map((item) => sanitizeInput(item)).filter((item) => item.length > 0);
+}
+function sanitizeObjectFields(obj, fields) {
+  const result = __spreadValues({}, obj);
+  for (const field of fields) {
+    const value = result[field];
+    if (typeof value === "string") {
+      result[field] = sanitizeInput(value);
+    } else if (Array.isArray(value)) {
+      result[field] = sanitizeArray(value);
+    }
+  }
+  return result;
+}
+var sanitizer_default = {
+  sanitizeHtml,
+  sanitizeUrl,
+  sanitizeInput,
+  sanitizeArray,
+  sanitizeObjectFields,
+  removeEventHandlers
+};
+
+export {
+  sanitizeHtml,
+  removeEventHandlers,
+  sanitizeUrl,
+  sanitizeInput,
+  sanitizeArray,
+  sanitizeObjectFields,
+  sanitizer_default
+};

package/dist/chunk-SS56XFLI.js

@@ -0,0 +1,19 @@
+// src/cache/cache-types.ts
+var DEFAULT_INMEMORY_CONFIG = {
+  maxSize: 1e5,
+  maxMemoryMB: 200,
+  evictionPolicy: "lru",
+  cleanupInterval: 6e4,
+  defaultTTL: 3600
+};
+var DEFAULT_HYBRID_CONFIG = {
+  backend: "hybrid",
+  fallbackOnRedisError: true,
+  writeToMemoryOnRedisError: true,
+  inmemory: DEFAULT_INMEMORY_CONFIG
+};
+
+export {
+  DEFAULT_INMEMORY_CONFIG,
+  DEFAULT_HYBRID_CONFIG
+};

package/dist/chunk-T3LJYAMO.js

@@ -0,0 +1,277 @@
+import {
+  JWTError
+} from "./chunk-AIH3F7JV.js";
+
+// src/auth/core/jwt/index.ts
+import { SignJWT, jwtVerify } from "jose";
+var JWTManager = class {
+  constructor(config, logger) {
+    this.config = config;
+    this.logger = logger;
+    this.secretKey = new TextEncoder().encode(config.secret);
+    if (config.secret.length < 32) {
+      throw new Error("JWT secret must be at least 32 characters long");
+    }
+  }
+  /**
+   * Access JWT 토큰 생성
+   */
+  async createAccessToken(payload) {
+    try {
+      const jwt = await new SignJWT(payload).setProtectedHeader({ alg: this.config.algorithm }).setIssuedAt().setExpirationTime(this.config.accessTokenExpiry).sign(this.secretKey);
+      this.logger.debug("Access token created successfully", {
+        userId: payload.userId,
+        expiresIn: this.config.accessTokenExpiry
+      });
+      return jwt;
+    } catch (error) {
+      this.logger.error("Failed to create access token", { error, payload });
+      throw new JWTError(
+        "Access token creation failed",
+        "TOKEN_CREATION_FAILED"
+      );
+    }
+  }
+  /**
+   * Refresh 토큰 생성
+   */
+  async createRefreshToken(userId) {
+    try {
+      const payload = {
+        userId,
+        tokenType: "refresh"
+      };
+      const jwt = await new SignJWT(payload).setProtectedHeader({ alg: this.config.algorithm }).setIssuedAt().setExpirationTime(this.config.refreshTokenExpiry).sign(this.secretKey);
+      this.logger.debug("Refresh token created successfully", {
+        userId,
+        expiresIn: this.config.refreshTokenExpiry
+      });
+      return jwt;
+    } catch (error) {
+      this.logger.error("Failed to create refresh token", { error, userId });
+      throw new JWTError(
+        "Refresh token creation failed",
+        "TOKEN_CREATION_FAILED"
+      );
+    }
+  }
+  /**
+   * 토큰 쌍 생성 (Access + Refresh)
+   */
+  async createTokenPair(user) {
+    try {
+      const [accessToken, refreshToken] = await Promise.all([
+        this.createAccessToken({
+          id: user.id,
+          userId: user.id,
+          email: user.email,
+          role: user.role,
+          emailVerified: user.emailVerified
+        }),
+        this.createRefreshToken(user.id)
+      ]);
+      this.logger.debug("Token pair created successfully", { userId: user.id });
+      return { accessToken, refreshToken };
+    } catch (error) {
+      this.logger.error("Failed to create token pair", {
+        error,
+        userId: user.id
+      });
+      throw new JWTError("Token pair creation failed", "TOKEN_CREATION_FAILED");
+    }
+  }
+  /**
+   * Access JWT 토큰 검증
+   */
+  async verifyAccessToken(token) {
+    try {
+      const { payload } = await jwtVerify(token, this.secretKey, {
+        algorithms: [this.config.algorithm]
+      });
+      const userId = payload.userId || payload.sub || payload.id;
+      if (!userId || !payload.email || !payload.role) {
+        throw new JWTError("Invalid JWT payload structure", "INVALID_PAYLOAD");
+      }
+      this.logger.debug("Access token verified successfully", {
+        userId
+      });
+      return {
+        id: userId,
+        userId,
+        email: payload.email,
+        role: payload.role,
+        emailVerified: payload.emailVerified,
+        tokenType: payload.tokenType,
+        iat: payload.iat,
+        exp: payload.exp
+      };
+    } catch (error) {
+      this.logger.error("Failed to verify access token", {
+        error: error.message,
+        token: token.substring(0, 20) + "..."
+      });
+      if (error.code === "ERR_JWT_EXPIRED") {
+        throw new JWTError("Token has expired", "TOKEN_EXPIRED");
+      }
+      throw new JWTError(
+        "Token verification failed",
+        "TOKEN_VERIFICATION_FAILED"
+      );
+    }
+  }
+  /**
+   * Refresh 토큰 검증
+   */
+  async verifyRefreshToken(token) {
+    try {
+      const { payload } = await jwtVerify(token, this.secretKey, {
+        algorithms: [this.config.algorithm]
+      });
+      const userId = payload.userId || payload.sub || payload.id;
+      if (!userId || payload.tokenType !== "refresh") {
+        throw new JWTError(
+          "Invalid refresh token payload structure",
+          "INVALID_PAYLOAD"
+        );
+      }
+      this.logger.debug("Refresh token verified successfully", {
+        userId
+      });
+      return {
+        userId,
+        tokenType: payload.tokenType
+      };
+    } catch (error) {
+      this.logger.error("Failed to verify refresh token", {
+        error: error.message,
+        token: token.substring(0, 20) + "..."
+      });
+      if (error.code === "ERR_JWT_EXPIRED") {
+        throw new JWTError(
+          "Refresh token has expired",
+          "REFRESH_TOKEN_EXPIRED"
+        );
+      }
+      throw new JWTError(
+        "Refresh token verification failed",
+        "TOKEN_VERIFICATION_FAILED"
+      );
+    }
+  }
+  /**
+   * Authorization 헤더에서 토큰 추출
+   */
+  extractTokenFromHeader(authHeader) {
+    if (!authHeader) {
+      return null;
+    }
+    const parts = authHeader.split(" ");
+    if (parts.length !== 2 || parts[0] !== "Bearer") {
+      return null;
+    }
+    return parts[1];
+  }
+  /**
+   * 토큰 만료 여부 확인
+   */
+  isTokenExpired(payload) {
+    if (!payload.exp) {
+      return true;
+    }
+    const currentTime = Math.floor(Date.now() / 1e3);
+    return payload.exp < currentTime;
+  }
+  /**
+   * 토큰 남은 시간 (초)
+   */
+  getTokenRemainingTime(payload) {
+    if (!payload.exp) {
+      return 0;
+    }
+    const currentTime = Math.floor(Date.now() / 1e3);
+    const remainingTime = payload.exp - currentTime;
+    return Math.max(0, remainingTime);
+  }
+  /**
+   * 토큰에서 사용자 정보 추출
+   */
+  extractUserFromPayload(payload) {
+    return {
+      id: payload.userId,
+      email: payload.email,
+      role: payload.role
+    };
+  }
+};
+var JWTService = class {
+  constructor(config) {
+    const logger = {
+      debug: () => {
+      },
+      // 테스트에서는 로그 출력 안 함
+      info: () => {
+      },
+      warn: () => {
+      },
+      error: (message, meta) => {
+        if (process.env.NODE_ENV === "test") {
+          console.error("[JWTService Error]", message, meta);
+        }
+      }
+    };
+    this.manager = new JWTManager(config, logger);
+  }
+  /**
+   * Access 토큰 생성 (sign으로 alias)
+   */
+  async sign(payload) {
+    return this.manager.createAccessToken(payload);
+  }
+  /**
+   * 토큰 검증
+   */
+  async verify(token) {
+    return this.manager.verifyAccessToken(token);
+  }
+  /**
+   * Refresh 토큰 생성
+   */
+  async createRefreshToken(userId) {
+    return this.manager.createRefreshToken(userId);
+  }
+  /**
+   * Refresh 토큰 검증
+   */
+  async verifyRefreshToken(token) {
+    return this.manager.verifyRefreshToken(token);
+  }
+  /**
+   * 토큰 쌍 생성
+   */
+  async createTokenPair(user) {
+    return this.manager.createTokenPair(user);
+  }
+  /**
+   * Access 토큰 생성
+   */
+  async createAccessToken(payload) {
+    return this.manager.createAccessToken(payload);
+  }
+  /**
+   * Access 토큰 검증
+   */
+  async verifyAccessToken(token) {
+    return this.manager.verifyAccessToken(token);
+  }
+  /**
+   * Authorization 헤더에서 토큰 추출
+   */
+  extractTokenFromHeader(authHeader) {
+    return this.manager.extractTokenFromHeader(authHeader != null ? authHeader : null);
+  }
+};
+
+export {
+  JWTManager,
+  JWTService
+};

package/dist/chunk-TDZJ6SAI.js

@@ -0,0 +1,34 @@
+// src/utils/format-number.ts
+function formatNumber(num) {
+  if (num === null || num === void 0) {
+    return "-";
+  }
+  const numericValue = typeof num === "string" ? parseFloat(num) : num;
+  if (isNaN(numericValue)) {
+    return "NaN";
+  }
+  if (!isFinite(numericValue)) {
+    return numericValue > 0 ? "Infinity" : "-Infinity";
+  }
+  const isNegative = numericValue < 0;
+  const absNum = Math.abs(numericValue);
+  if (absNum < 1e3) {
+    return numericValue.toString();
+  }
+  if (absNum < 1e6) {
+    return numericValue.toLocaleString();
+  }
+  if (absNum < 1e7) {
+    return numericValue.toLocaleString();
+  }
+  const formatted = (absNum / 1e6).toFixed(1) + "M";
+  return isNegative ? "-" + formatted : formatted;
+}
+function formatChartNumber(num) {
+  return formatNumber(num);
+}
+
+export {
+  formatNumber,
+  formatChartNumber
+};

package/dist/chunk-TEIYA7U4.js

@@ -0,0 +1,72 @@
+import {
+  __spreadValues
+} from "./chunk-ORMEWXMH.js";
+
+// src/error/recovery/degradation.ts
+var FeatureDegradation = class {
+  /**
+   * 기능 실행 (실패해도 앱은 계속)
+   */
+  static async execute(featureName, fn, fallbackValue) {
+    try {
+      const data = await fn();
+      return {
+        success: true,
+        data
+      };
+    } catch (error) {
+      console.warn(`[FeatureDegradation] Feature "${featureName}" failed:`, error);
+      return {
+        success: false,
+        data: fallbackValue,
+        error
+      };
+    }
+  }
+  /**
+   * 여러 기능을 병렬로 실행 (일부 실패해도 계속)
+   */
+  static async executeAll(features) {
+    const promises = features.map(
+      (feature) => this.execute(feature.name, feature.fn, feature.fallbackValue).then(
+        (result) => __spreadValues({
+          name: feature.name
+        }, result)
+      )
+    );
+    return await Promise.all(promises);
+  }
+  /**
+   * 타임아웃 포함 실행
+   */
+  static async executeWithTimeout(featureName, fn, timeoutMs, fallbackValue) {
+    try {
+      const data = await Promise.race([
+        fn(),
+        new Promise(
+          (_, reject) => setTimeout(() => reject(new Error("Timeout")), timeoutMs)
+        )
+      ]);
+      return {
+        success: true,
+        data
+      };
+    } catch (error) {
+      const timedOut = error instanceof Error && error.message === "Timeout";
+      console.warn(
+        `[FeatureDegradation] Feature "${featureName}" ${timedOut ? "timed out" : "failed"}:`,
+        error
+      );
+      return {
+        success: false,
+        data: fallbackValue,
+        error,
+        timedOut
+      };
+    }
+  }
+};
+
+export {
+  FeatureDegradation
+};

package/dist/chunk-TMVS4F7E.js

@@ -0,0 +1,88 @@
+import {
+  getErrorMessage
+} from "./chunk-EEUBKZV4.js";
+import {
+  AppError
+} from "./chunk-MLGO3HLS.js";
+import {
+  ERROR_CODES
+} from "./chunk-Y3OTJH2S.js";
+import {
+  logger
+} from "./chunk-EZR55KV2.js";
+import {
+  __spreadValues
+} from "./chunk-ORMEWXMH.js";
+
+// src/middleware/error-handler.ts
+import { NextResponse } from "next/server";
+import { z } from "zod";
+var errorHandlerMiddleware = async (context, next) => {
+  var _a, _b;
+  try {
+    return await next();
+  } catch (error) {
+    if (error instanceof AppError) {
+      return createErrorResponse(
+        error.code,
+        error.message,
+        context.locale,
+        context.requestId,
+        error.details
+      );
+    }
+    if (error instanceof z.ZodError) {
+      const issues = error.errors.map((e) => ({
+        path: e.path.join("."),
+        message: e.message,
+        code: e.code
+      }));
+      const firstMessage = ((_a = issues[0]) == null ? void 0 : _a.message) || "Validation failed";
+      return createErrorResponse(
+        ERROR_CODES.VALIDATION_ERROR.code,
+        firstMessage,
+        context.locale,
+        context.requestId,
+        { issues }
+      );
+    }
+    logger.error("[ErrorHandler] Unexpected error:", error);
+    const isProduction = process.env.NODE_ENV === "production";
+    const safeMessage = isProduction ? "Internal server error" : error instanceof Error ? error.message : "Unknown error";
+    return createErrorResponse(
+      ERROR_CODES.INTERNAL_SERVER_ERROR.code,
+      safeMessage,
+      context.locale,
+      context.requestId,
+      // 개발 환경에서만 스택 트레이스 포함
+      !isProduction && error instanceof Error ? { stack: (_b = error.stack) == null ? void 0 : _b.split("\n").slice(0, 5) } : void 0
+    );
+  }
+};
+function createErrorResponse(code, message, locale, requestId, metadata) {
+  const userMessage = getErrorMessage(code, locale);
+  const httpStatus = Math.floor(code / 100);
+  const errorResponse = {
+    success: false,
+    error: __spreadValues({
+      code,
+      message,
+      userMessage: {
+        title: userMessage.title,
+        description: userMessage.description,
+        action: userMessage.action
+      },
+      requestId
+    }, metadata && { metadata })
+  };
+  return NextResponse.json(errorResponse, {
+    status: httpStatus,
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+}
+
+export {
+  errorHandlerMiddleware
+};