@withwiz/toolkit 0.1.0

package/dist/chunk-XPASCCUA.js

@@ -0,0 +1,404 @@
+import {
+  AppError
+} from "./chunk-MLGO3HLS.js";
+import {
+  ERROR_CODES,
+  formatErrorMessage
+} from "./chunk-Y3OTJH2S.js";
+import {
+  logApiRequest,
+  logApiResponse,
+  logger
+} from "./chunk-EZR55KV2.js";
+
+// src/utils/error-processor.ts
+import { NextResponse } from "next/server";
+import { z } from "zod";
+var PRISMA_ERROR_MAP = {
+  P2000: { code: 40001, message: "\uC785\uB825\uAC12\uC774 \uB108\uBB34 \uAE41\uB2C8\uB2E4.", status: 400 },
+  P2001: { code: 40401, message: "\uC694\uCCAD\uD55C \uB808\uCF54\uB4DC\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.", status: 404 },
+  P2002: { code: 40905, message: "\uC774\uBBF8 \uC874\uC7AC\uD558\uB294 \uB370\uC774\uD130\uC785\uB2C8\uB2E4.", status: 409 },
+  P2003: { code: 40001, message: "\uC678\uB798 \uD0A4 \uC81C\uC57D \uC870\uAC74 \uC704\uBC18\uC785\uB2C8\uB2E4.", status: 400 },
+  P2004: { code: 40001, message: "\uB370\uC774\uD130\uBCA0\uC774\uC2A4 \uC81C\uC57D \uC870\uAC74 \uC704\uBC18\uC785\uB2C8\uB2E4.", status: 400 },
+  P2005: { code: 40001, message: "\uC720\uD6A8\uD558\uC9C0 \uC54A\uC740 \uD544\uB4DC \uAC12\uC785\uB2C8\uB2E4.", status: 400 },
+  P2006: { code: 40001, message: "\uC720\uD6A8\uD558\uC9C0 \uC54A\uC740 \uAC12\uC785\uB2C8\uB2E4.", status: 400 },
+  P2011: { code: 40004, message: "Null \uC81C\uC57D \uC870\uAC74 \uC704\uBC18\uC785\uB2C8\uB2E4.", status: 400 },
+  P2014: { code: 40001, message: "\uD544\uC218 \uAD00\uACC4 \uC704\uBC18\uC785\uB2C8\uB2E4.", status: 400 },
+  P2015: { code: 40401, message: "\uAD00\uB828 \uB808\uCF54\uB4DC\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.", status: 404 },
+  P2016: { code: 40001, message: "\uCFFC\uB9AC \uD574\uC11D \uC624\uB958\uC785\uB2C8\uB2E4.", status: 400 },
+  P2017: { code: 40001, message: "\uAD00\uACC4\uAC00 \uC5F0\uACB0\uB418\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4.", status: 400 },
+  P2018: { code: 40401, message: "\uC5F0\uACB0\uB41C \uB808\uCF54\uB4DC\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.", status: 404 },
+  P2025: { code: 40401, message: "\uC694\uCCAD\uD55C \uB808\uCF54\uB4DC\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.", status: 404 }
+};
+var ErrorProcessor = class {
+  /**
+   * 에러를 처리하여 표준화된 응답으로 변환
+   */
+  static process(error) {
+    if (error instanceof AppError) {
+      return error.toJSON();
+    }
+    if (error instanceof z.ZodError) {
+      return this.handleZodError(error);
+    }
+    if (error instanceof Error) {
+      const prismaError = this.extractPrismaError(error);
+      if (prismaError) {
+        return prismaError;
+      }
+      if (error.message.includes("Unique constraint failed")) {
+        return {
+          code: ERROR_CODES.DUPLICATE_RESOURCE.code,
+          message: formatErrorMessage(ERROR_CODES.DUPLICATE_RESOURCE.code),
+          status: 409,
+          key: "DUPLICATE_RESOURCE",
+          category: "conflict",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      }
+      if (error.message.includes("not found") || error.message.includes("Not found")) {
+        return {
+          code: ERROR_CODES.NOT_FOUND.code,
+          message: formatErrorMessage(ERROR_CODES.NOT_FOUND.code, error.message),
+          status: 404,
+          key: "NOT_FOUND",
+          category: "resource",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      }
+      if (error.message.includes("unauthorized") || error.message.includes("Unauthorized")) {
+        return {
+          code: ERROR_CODES.UNAUTHORIZED.code,
+          message: formatErrorMessage(ERROR_CODES.UNAUTHORIZED.code, error.message),
+          status: 401,
+          key: "UNAUTHORIZED",
+          category: "auth",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      }
+      return {
+        code: ERROR_CODES.SERVER_ERROR.code,
+        message: formatErrorMessage(ERROR_CODES.SERVER_ERROR.code),
+        status: 500,
+        key: "SERVER_ERROR",
+        category: "server",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }
+    return {
+      code: ERROR_CODES.INTERNAL_SERVER_ERROR.code,
+      message: formatErrorMessage(ERROR_CODES.INTERNAL_SERVER_ERROR.code),
+      status: 500,
+      key: "INTERNAL_SERVER_ERROR",
+      category: "server",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /**
+   * Zod 검증 에러 처리
+   */
+  static handleZodError(error) {
+    var _a;
+    const issues = error.errors.map((err) => ({
+      path: err.path.join("."),
+      message: err.message,
+      code: err.code
+    }));
+    const firstMessage = ((_a = issues[0]) == null ? void 0 : _a.message) || ERROR_CODES.VALIDATION_ERROR.message;
+    return {
+      code: ERROR_CODES.VALIDATION_ERROR.code,
+      message: formatErrorMessage(ERROR_CODES.VALIDATION_ERROR.code, firstMessage),
+      status: 400,
+      key: "VALIDATION_ERROR",
+      category: "validation",
+      details: { issues },
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /**
+   * Prisma 에러 추출 및 처리
+   */
+  static extractPrismaError(error) {
+    const codeMatch = error.message.match(/P\d{4}/);
+    if (!codeMatch) return null;
+    const prismaCode = codeMatch[0];
+    const mapping = PRISMA_ERROR_MAP[prismaCode];
+    if (mapping) {
+      return {
+        code: mapping.code,
+        message: formatErrorMessage(mapping.code, mapping.message),
+        status: mapping.status,
+        key: "DATABASE_ERROR",
+        category: "server",
+        details: { prismaCode },
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }
+    logger.error("Unmapped Prisma error", { prismaCode, message: error.message });
+    return {
+      code: ERROR_CODES.DATABASE_ERROR.code,
+      message: formatErrorMessage(ERROR_CODES.DATABASE_ERROR.code),
+      status: 500,
+      key: "DATABASE_ERROR",
+      category: "server",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /**
+   * 에러를 NextResponse로 변환
+   */
+  static toResponse(error, requestPath) {
+    const processed = this.process(error);
+    if (processed.status >= 500) {
+      logger.error("Server error", {
+        code: processed.code,
+        message: processed.message,
+        status: processed.status,
+        path: requestPath,
+        details: processed.details,
+        originalError: error instanceof Error ? error.stack : error
+      });
+    } else if (processed.status >= 400) {
+      logger.warn("Client error", {
+        code: processed.code,
+        message: processed.message,
+        status: processed.status,
+        path: requestPath
+      });
+    }
+    return NextResponse.json(
+      {
+        success: false,
+        error: {
+          code: processed.code,
+          message: processed.message,
+          details: processed.details
+        }
+      },
+      { status: processed.status }
+    );
+  }
+  /**
+   * 에러 핸들러 래퍼 함수 (간단한 버전)
+   * try-catch 블록을 대체하여 사용
+   */
+  static withErrorHandling(handler) {
+    return (async (...args) => {
+      try {
+        return await handler(...args);
+      } catch (error) {
+        return this.toResponse(error);
+      }
+    });
+  }
+};
+function withErrorHandling(handler, options = {}) {
+  return async (request, ...args) => {
+    var _a;
+    const startTime = Date.now();
+    try {
+      await logApiRequest(request);
+      const response = await handler(request, ...args);
+      logApiResponse(request, response);
+      if (options.preserveCustomResponses && response.status !== 200) {
+        return response;
+      }
+      return response;
+    } catch (error) {
+      const responseTime = Date.now() - startTime;
+      if (options.customErrorHandler) {
+        try {
+          const customResponse = options.customErrorHandler(error, request);
+          logApiResponse(request, customResponse);
+          return customResponse;
+        } catch (customError) {
+          logger.error("Custom error handler failed:", { error: customError, originalError: error });
+        }
+      }
+      let response;
+      if (error instanceof z.ZodError) {
+        const issues = error.errors.map((err) => ({
+          path: err.path.join("."),
+          message: err.message,
+          code: err.code
+        }));
+        const firstMessage = ((_a = issues[0]) == null ? void 0 : _a.message) || ERROR_CODES.VALIDATION_ERROR.message;
+        response = NextResponse.json(
+          {
+            success: false,
+            error: {
+              code: ERROR_CODES.VALIDATION_ERROR.code,
+              message: formatErrorMessage(ERROR_CODES.VALIDATION_ERROR.code, firstMessage),
+              details: { issues }
+            }
+          },
+          { status: 400 }
+        );
+        logger.warn("Validation error:", {
+          error: issues,
+          responseTime: `${responseTime}ms`,
+          path: request.nextUrl.pathname
+        });
+      } else if (error instanceof AppError) {
+        response = NextResponse.json(
+          {
+            success: false,
+            error: {
+              code: error.code,
+              message: error.message,
+              details: error.details
+            }
+          },
+          { status: error.status }
+        );
+        logger[options.logLevel || "error"]("App error:", {
+          error: error.message,
+          code: error.code,
+          status: error.status,
+          responseTime: `${responseTime}ms`,
+          path: request.nextUrl.pathname
+        });
+      } else if (error instanceof Error) {
+        response = ErrorProcessor.toResponse(error, request.nextUrl.pathname);
+        logger.error("Unexpected error:", {
+          error: error.message,
+          stack: error.stack,
+          responseTime: `${responseTime}ms`,
+          path: request.nextUrl.pathname
+        });
+      } else {
+        response = NextResponse.json(
+          {
+            success: false,
+            error: {
+              code: ERROR_CODES.SERVER_ERROR.code,
+              message: formatErrorMessage(ERROR_CODES.SERVER_ERROR.code)
+            }
+          },
+          { status: 500 }
+        );
+        logger.error("Unknown error:", {
+          error,
+          responseTime: `${responseTime}ms`,
+          path: request.nextUrl.pathname
+        });
+      }
+      if (options.maskSensitiveInfo) {
+        response = await maskSensitiveInfo(response);
+      }
+      logApiResponse(request, response);
+      return response;
+    }
+  };
+}
+async function maskSensitiveInfo(response) {
+  var _a, _b;
+  try {
+    const clonedResponse = response.clone();
+    const body = await clonedResponse.json();
+    if ((_a = body.error) == null ? void 0 : _a.details) {
+      delete body.error.details;
+    }
+    if ((_b = body.data) == null ? void 0 : _b.password) {
+      body.data.password = "***";
+    }
+    return NextResponse.json(body, { status: response.status });
+  } catch (e) {
+    return response;
+  }
+}
+function handlePrismaError(error) {
+  if (error && typeof error === "object" && "code" in error) {
+    const prismaError = error;
+    if (prismaError.code === "P2002") {
+      const errorInfo2 = ERROR_CODES.DUPLICATE_RESOURCE;
+      return NextResponse.json(
+        {
+          success: false,
+          error: {
+            code: errorInfo2.code,
+            message: formatErrorMessage(errorInfo2.code)
+          }
+        },
+        { status: errorInfo2.status }
+      );
+    }
+    if (prismaError.code === "P2025") {
+      const errorInfo2 = ERROR_CODES.NOT_FOUND;
+      return NextResponse.json(
+        {
+          success: false,
+          error: {
+            code: errorInfo2.code,
+            message: formatErrorMessage(errorInfo2.code)
+          }
+        },
+        { status: errorInfo2.status }
+      );
+    }
+    if (prismaError.code === "P2003") {
+      const errorInfo2 = ERROR_CODES.BUSINESS_RULE_VIOLATION;
+      return NextResponse.json(
+        {
+          success: false,
+          error: {
+            code: errorInfo2.code,
+            message: formatErrorMessage(errorInfo2.code)
+          }
+        },
+        { status: errorInfo2.status }
+      );
+    }
+  }
+  const errorInfo = ERROR_CODES.DATABASE_ERROR;
+  return NextResponse.json(
+    {
+      success: false,
+      error: {
+        code: errorInfo.code,
+        message: formatErrorMessage(errorInfo.code)
+      }
+    },
+    { status: errorInfo.status }
+  );
+}
+function throwBusinessRuleError(message, code) {
+  throw code ? new AppError(code, message) : AppError.businessRule(message);
+}
+function throwNotFoundError(message, code) {
+  throw code ? new AppError(code, message) : AppError.notFound(message);
+}
+function throwConflictError(message, code) {
+  throw code ? new AppError(code, message) : AppError.conflict(message);
+}
+function throwForbiddenError(message, code) {
+  throw code ? new AppError(code, message) : AppError.forbidden(message);
+}
+function throwUnauthorizedError(message, code) {
+  throw code ? new AppError(code, message) : AppError.unauthorized(message);
+}
+function throwValidationError(message, code) {
+  throw code ? new AppError(code, message) : AppError.validation(message);
+}
+function throwBadRequestError(message, code) {
+  throw code ? new AppError(code, message) : AppError.badRequest(message);
+}
+var processError = ErrorProcessor.process.bind(ErrorProcessor);
+var errorToResponse = ErrorProcessor.toResponse.bind(ErrorProcessor);
+var error_processor_default = ErrorProcessor;
+
+export {
+  ErrorProcessor,
+  withErrorHandling,
+  handlePrismaError,
+  throwBusinessRuleError,
+  throwNotFoundError,
+  throwConflictError,
+  throwForbiddenError,
+  throwUnauthorizedError,
+  throwValidationError,
+  throwBadRequestError,
+  processError,
+  errorToResponse,
+  error_processor_default
+};

package/dist/chunk-XRRPEBKB.js

@@ -0,0 +1,231 @@
+// src/auth/core/jwt/client.ts
+var JWTClientManager = class {
+  constructor(storageKey = "jwt_tokens") {
+    this.storageKey = storageKey;
+  }
+  /**
+   * 로컬 스토리지에서 토큰 가져오기
+   */
+  getStoredTokens() {
+    try {
+      if (typeof window === "undefined") {
+        return null;
+      }
+      const stored = localStorage.getItem(this.storageKey);
+      if (!stored) {
+        return null;
+      }
+      const tokens = JSON.parse(stored);
+      if (tokens.expiresAt && Date.now() > tokens.expiresAt) {
+        console.debug("Stored tokens expired, clearing storage");
+        this.clearStoredTokens();
+        return null;
+      }
+      return tokens;
+    } catch (error) {
+      console.error("Failed to get stored tokens", { error });
+      return null;
+    }
+  }
+  /**
+   * 토큰을 로컬 스토리지에 저장
+   */
+  storeTokens(accessToken, refreshToken, expiresIn = 7 * 24 * 60 * 60) {
+    try {
+      if (typeof window === "undefined") {
+        return;
+      }
+      const expiresAt = Date.now() + expiresIn * 1e3;
+      const tokens = {
+        accessToken,
+        refreshToken,
+        expiresAt
+      };
+      localStorage.setItem(this.storageKey, JSON.stringify(tokens));
+      console.debug("Tokens stored successfully", {
+        expiresAt: new Date(expiresAt).toISOString()
+      });
+    } catch (error) {
+      console.error("Failed to store tokens", { error });
+    }
+  }
+  /**
+   * 로컬 스토리지에서 토큰 제거
+   */
+  clearStoredTokens() {
+    try {
+      if (typeof window === "undefined") {
+        return;
+      }
+      localStorage.removeItem(this.storageKey);
+      console.debug("Stored tokens cleared");
+    } catch (error) {
+      console.error("Failed to clear stored tokens", { error });
+    }
+  }
+  /**
+   * JWT 토큰에서 페이로드 디코딩 (검증 없음)
+   */
+  decodeJWTPayload(token) {
+    try {
+      const parts = token.split(".");
+      if (parts.length !== 3) {
+        throw new Error("Invalid JWT format");
+      }
+      const payload = JSON.parse(atob(parts[1]));
+      return payload;
+    } catch (error) {
+      console.error("Failed to decode JWT payload", { error });
+      return null;
+    }
+  }
+  /**
+   * 토큰 만료 여부 확인
+   */
+  isTokenExpired(token) {
+    try {
+      const payload = this.decodeJWTPayload(token);
+      if (!payload || !payload.exp) {
+        return true;
+      }
+      const currentTime = Math.floor(Date.now() / 1e3);
+      return payload.exp < currentTime;
+    } catch (error) {
+      console.error("Failed to check token expiration", { error });
+      return true;
+    }
+  }
+  /**
+   * 토큰 남은 시간 (초)
+   */
+  getTokenRemainingTime(token) {
+    try {
+      const payload = this.decodeJWTPayload(token);
+      if (!payload || !payload.exp) {
+        return 0;
+      }
+      const currentTime = Math.floor(Date.now() / 1e3);
+      const remainingTime = payload.exp - currentTime;
+      return Math.max(0, remainingTime);
+    } catch (error) {
+      console.error("Failed to get token remaining time", { error });
+      return 0;
+    }
+  }
+  /**
+   * 토큰에서 사용자 정보 추출
+   */
+  extractUserFromToken(token) {
+    try {
+      const payload = this.decodeJWTPayload(token);
+      if (!payload || !payload.userId || !payload.email || !payload.role) {
+        return null;
+      }
+      return {
+        userId: payload.userId,
+        email: payload.email,
+        role: payload.role
+      };
+    } catch (error) {
+      console.error("Failed to extract user from token", { error });
+      return null;
+    }
+  }
+  /**
+   * 토큰에서 사용자 role 추출
+   */
+  getUserRole(token) {
+    if (!token) {
+      return "USER";
+    }
+    const user = this.extractUserFromToken(token);
+    return (user == null ? void 0 : user.role) || "USER";
+  }
+  /**
+   * Authorization 헤더 생성
+   */
+  createAuthHeader(token) {
+    return `Bearer ${token}`;
+  }
+  /**
+   * API 요청용 헤더 생성
+   */
+  createApiHeaders(token) {
+    return {
+      Authorization: this.createAuthHeader(token),
+      "Content-Type": "application/json"
+    };
+  }
+  /**
+   * 토큰이 곧 만료되는지 확인 (5분 이내)
+   */
+  isTokenExpiringSoon(token, thresholdSeconds = 300) {
+    const remainingTime = this.getTokenRemainingTime(token);
+    return remainingTime > 0 && remainingTime <= thresholdSeconds;
+  }
+  /**
+   * 토큰 만료 시간 포맷팅
+   */
+  getTokenExpirationString(token) {
+    try {
+      const payload = this.decodeJWTPayload(token);
+      if (!payload || !payload.exp) {
+        return null;
+      }
+      const expirationDate = new Date(payload.exp * 1e3);
+      return expirationDate.toLocaleString();
+    } catch (error) {
+      console.error("Failed to get token expiration string", { error });
+      return null;
+    }
+  }
+  /**
+   * 토큰 발급 시간 포맷팅
+   */
+  getTokenIssuedAtString(token) {
+    try {
+      const payload = this.decodeJWTPayload(token);
+      if (!payload || !payload.iat) {
+        return null;
+      }
+      const issuedDate = new Date(payload.iat * 1e3);
+      return issuedDate.toLocaleString();
+    } catch (error) {
+      console.error("Failed to get token issued at string", { error });
+      return null;
+    }
+  }
+};
+var defaultManager = new JWTClientManager();
+var getStoredTokens = () => defaultManager.getStoredTokens();
+var storeTokens = (accessToken, refreshToken, expiresIn) => defaultManager.storeTokens(accessToken, refreshToken, expiresIn);
+var clearStoredTokens = () => defaultManager.clearStoredTokens();
+var clearTokens = () => defaultManager.clearStoredTokens();
+var decodeJWTPayload = (token) => defaultManager.decodeJWTPayload(token);
+var isTokenExpired = (token) => defaultManager.isTokenExpired(token);
+var getTokenRemainingTime = (token) => defaultManager.getTokenRemainingTime(token);
+var extractUserFromToken = (token) => defaultManager.extractUserFromToken(token);
+var getUserRole = (token) => defaultManager.getUserRole(token);
+var createAuthHeader = (token) => defaultManager.createAuthHeader(token);
+var createApiHeaders = (token) => defaultManager.createApiHeaders(token);
+var isTokenExpiringSoon = (token) => defaultManager.isTokenExpiringSoon(token);
+var getTokenExpirationString = (token) => defaultManager.getTokenExpirationString(token);
+var getTokenIssuedAtString = (token) => defaultManager.getTokenIssuedAtString(token);
+
+export {
+  JWTClientManager,
+  getStoredTokens,
+  storeTokens,
+  clearStoredTokens,
+  clearTokens,
+  decodeJWTPayload,
+  isTokenExpired,
+  getTokenRemainingTime,
+  extractUserFromToken,
+  getUserRole,
+  createAuthHeader,
+  createApiHeaders,
+  isTokenExpiringSoon,
+  getTokenExpirationString,
+  getTokenIssuedAtString
+};