@withwiz/toolkit 0.1.0

package/dist/chunk-GL2NANFH.js

@@ -0,0 +1,434 @@
+import {
+  getRedisClient,
+  isRedisGloballyDisabled,
+  notifyRedisError,
+  resetRedisGlobalState
+} from "./chunk-6LTZCXNC.js";
+import {
+  getENV,
+  isCacheEnabled
+} from "./chunk-I47QEDTX.js";
+import {
+  logger
+} from "./chunk-EZR55KV2.js";
+import {
+  __spreadValues
+} from "./chunk-ORMEWXMH.js";
+
+// src/cache/redis-cache-manager.ts
+var RedisCacheManager = class _RedisCacheManager {
+  constructor(prefix) {
+    this.prefix = prefix;
+    this.metrics = {
+      hits: 0,
+      misses: 0,
+      errors: 0,
+      totalRequests: 0,
+      hitRate: 0,
+      averageResponseTime: 0
+    };
+    this.connectionStatus = {
+      isConnected: false,
+      connectionErrors: 0
+    };
+  }
+  // globalThis를 사용하여 프로세스 레벨에서 인스턴스 관리 (HMR 안전)
+  static getGlobalInstances() {
+    if (!globalThis.__redisCacheManagerInstances) {
+      globalThis.__redisCacheManagerInstances = /* @__PURE__ */ new Map();
+    }
+    return globalThis.__redisCacheManagerInstances;
+  }
+  // 정적 팩토리 메서드로 인스턴스 가져오기
+  static getInstance(prefix) {
+    const globalInstances = _RedisCacheManager.getGlobalInstances();
+    if (!globalInstances.has(prefix)) {
+      const instance = new _RedisCacheManager(prefix);
+      globalInstances.set(prefix, instance);
+      logger.debug(`RedisCacheManager initialization: ${prefix}`, {
+        prefix,
+        redisAvailable: !!getRedisClient(),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+    return globalInstances.get(prefix);
+  }
+  // 인스턴스 초기화 (테스트용)
+  static clearInstances() {
+    _RedisCacheManager.getGlobalInstances().clear();
+  }
+  // 메트릭 업데이트
+  updateMetrics(responseTime) {
+    this.metrics.hitRate = this.metrics.totalRequests > 0 ? this.metrics.hits / this.metrics.totalRequests * 100 : 0;
+    const totalTime = this.metrics.averageResponseTime * (this.metrics.totalRequests - 1) + responseTime;
+    this.metrics.averageResponseTime = totalTime / this.metrics.totalRequests;
+  }
+  // 메트릭 조회
+  getMetrics() {
+    return __spreadValues({}, this.metrics);
+  }
+  // 연결 상태 조회
+  getConnectionStatus() {
+    return __spreadValues({}, this.connectionStatus);
+  }
+  // Redis 연결 상태 확인 (PING 테스트)
+  async checkConnection() {
+    const redis = getRedisClient();
+    if (!redis) {
+      this.connectionStatus.isConnected = false;
+      return false;
+    }
+    try {
+      const pingResult = await redis.ping();
+      if (pingResult === "PONG") {
+        this.connectionStatus.isConnected = true;
+        this.connectionStatus.lastPingTime = /* @__PURE__ */ new Date();
+        return true;
+      } else {
+        this.connectionStatus.isConnected = false;
+        return false;
+      }
+    } catch (error) {
+      this.connectionStatus.isConnected = false;
+      this.connectionStatus.connectionErrors++;
+      this.connectionStatus.lastConnectionError = error instanceof Error ? error.message : "Unknown error";
+      this.connectionStatus.lastConnectionErrorTime = /* @__PURE__ */ new Date();
+      return false;
+    }
+  }
+  // 캐시 설정 정보 조회
+  getConfig() {
+    const ENV = getENV();
+    return {
+      prefix: this.prefix,
+      enabled: true,
+      redisAvailable: !!getRedisClient(),
+      envVars: {
+        CACHE_ENABLED: ENV.CACHE.ENABLED ? "true" : "false",
+        UPSTASH_REDIS_REST_URL: ENV.REDIS.URL ? "\uC124\uC815\uB428" : "\uBBF8\uC124\uC815",
+        UPSTASH_REDIS_REST_TOKEN: ENV.REDIS.TOKEN ? "\uC124\uC815\uB428" : "\uBBF8\uC124\uC815"
+      }
+    };
+  }
+  getKey(key) {
+    return `${this.prefix}:${key}`;
+  }
+  // BigInt를 Number로 변환하는 헬퍼 함수
+  serializeData(data) {
+    if (data === null || data === void 0) {
+      return data;
+    }
+    if (typeof data === "bigint") {
+      return Number(data);
+    }
+    if (Array.isArray(data)) {
+      return data.map((item) => this.serializeData(item));
+    }
+    if (typeof data === "object") {
+      const serialized = {};
+      for (const [key, value] of Object.entries(data)) {
+        serialized[key] = this.serializeData(value);
+      }
+      return serialized;
+    }
+    return data;
+  }
+  async get(key) {
+    var _a;
+    const startTime = Date.now();
+    const fullKey = `${this.prefix}:${key}`;
+    this.metrics.totalRequests++;
+    if (!isCacheEnabled()) {
+      logger.debug(
+        `Cache retrieval skipped due to cache disabled: ${fullKey}`,
+        {
+          prefix: this.prefix,
+          key,
+          fullKey,
+          cacheEnabled: isCacheEnabled()
+        }
+      );
+      this.metrics.misses++;
+      this.updateMetrics(0);
+      return null;
+    }
+    if (isRedisGloballyDisabled()) {
+      this.metrics.misses++;
+      this.updateMetrics(0);
+      return null;
+    }
+    try {
+      const redis = getRedisClient();
+      if (!redis) {
+        logger.warn(
+          `Cache retrieval failed due to Redis unavailability: ${fullKey}`,
+          {
+            prefix: this.prefix,
+            key,
+            fullKey
+          }
+        );
+        this.metrics.errors++;
+        return null;
+      }
+      logger.debug(`Cache retrieval started: ${fullKey}`, {
+        prefix: this.prefix,
+        key,
+        fullKey,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const value = await redis.get(fullKey);
+      const responseTime = Date.now() - startTime;
+      this.connectionStatus.isConnected = true;
+      this.connectionStatus.lastPingTime = /* @__PURE__ */ new Date();
+      resetRedisGlobalState();
+      if (value !== null && value !== void 0) {
+        this.metrics.hits++;
+        this.updateMetrics(responseTime);
+        logger.debug(`[Cache:R] hit: ${fullKey}`, {
+          prefix: this.prefix,
+          key,
+          fullKey,
+          responseTime: `${responseTime}ms`,
+          valueType: typeof value,
+          valueSize: ((_a = JSON.stringify(value)) == null ? void 0 : _a.length) || 0
+        });
+        return value;
+      } else {
+        this.metrics.misses++;
+        this.updateMetrics(responseTime);
+        logger.debug(`[Cache:R] miss: ${fullKey} (${responseTime}ms)`);
+        return null;
+      }
+    } catch (error) {
+      const responseTime = Date.now() - startTime;
+      const errorMessage = error instanceof Error ? error.message : "\uC54C \uC218 \uC5C6\uB294 \uC624\uB958";
+      this.metrics.errors++;
+      this.connectionStatus.connectionErrors++;
+      this.connectionStatus.lastConnectionError = errorMessage;
+      this.connectionStatus.lastConnectionErrorTime = /* @__PURE__ */ new Date();
+      this.updateMetrics(responseTime);
+      notifyRedisError(
+        error instanceof Error ? error : new Error(errorMessage),
+        `CacheManager.get:${this.prefix}`
+      );
+      logger.error(`Cache retrieval failed: ${fullKey}`, {
+        prefix: this.prefix,
+        key,
+        fullKey,
+        error: errorMessage,
+        responseTime: `${responseTime}ms`,
+        stack: error instanceof Error ? error.stack : void 0
+      });
+      return null;
+    }
+  }
+  async set(key, value, ttl) {
+    var _a, _b;
+    const startTime = Date.now();
+    const fullKey = `${this.prefix}:${key}`;
+    if (value === void 0) {
+      logger.warn(`[Cache:R] Attempted to set undefined value: ${fullKey}`);
+      return;
+    }
+    if (!isCacheEnabled()) {
+      logger.debug(`Cache storage skipped due to cache disabled: ${fullKey}`, {
+        prefix: this.prefix,
+        key,
+        fullKey,
+        cacheEnabled: isCacheEnabled()
+      });
+      return;
+    }
+    if (isRedisGloballyDisabled()) {
+      return;
+    }
+    try {
+      const redis = getRedisClient();
+      if (!redis) {
+        logger.warn(
+          `Cache storage failed due to Redis unavailability: ${fullKey}`,
+          {
+            prefix: this.prefix,
+            key,
+            fullKey,
+            valueType: typeof value,
+            valueSize: ((_a = JSON.stringify(value)) == null ? void 0 : _a.length) || 0,
+            ttl: ttl ? `${ttl}s` : "\uAE30\uBCF8\uAC12",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          }
+        );
+        return;
+      }
+      logger.debug(`Cache storage started: ${fullKey}`, {
+        prefix: this.prefix,
+        key,
+        fullKey,
+        valueType: typeof value,
+        valueSize: ((_b = JSON.stringify(value)) == null ? void 0 : _b.length) || 0,
+        ttl: ttl ? `${ttl}s` : "\uAE30\uBCF8\uAC12",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      if (ttl) {
+        await redis.set(fullKey, value, { ex: ttl });
+      } else {
+        await redis.set(fullKey, value);
+      }
+      const responseTime = Date.now() - startTime;
+      this.connectionStatus.isConnected = true;
+      this.connectionStatus.lastPingTime = /* @__PURE__ */ new Date();
+      resetRedisGlobalState();
+      logger.info(`[Cache:R] set: ${fullKey}`, {
+        prefix: this.prefix,
+        key,
+        fullKey,
+        responseTime: `${responseTime}ms`,
+        ttl: ttl ? `${ttl}s` : "\uAE30\uBCF8\uAC12"
+      });
+    } catch (error) {
+      const responseTime = Date.now() - startTime;
+      const errorMessage = error instanceof Error ? error.message : "\uC54C \uC218 \uC5C6\uB294 \uC624\uB958";
+      this.connectionStatus.connectionErrors++;
+      this.connectionStatus.lastConnectionError = errorMessage;
+      this.connectionStatus.lastConnectionErrorTime = /* @__PURE__ */ new Date();
+      notifyRedisError(
+        error instanceof Error ? error : new Error(errorMessage),
+        `CacheManager.set:${this.prefix}`
+      );
+      logger.error(`Cache storage failed: ${fullKey}`, {
+        prefix: this.prefix,
+        key,
+        fullKey,
+        error: errorMessage,
+        responseTime: `${responseTime}ms`,
+        valueType: typeof value,
+        ttl,
+        stack: error instanceof Error ? error.stack : void 0
+      });
+    }
+  }
+  async delete(key) {
+    const startTime = Date.now();
+    const fullKey = `${this.prefix}:${key}`;
+    try {
+      const redis = getRedisClient();
+      if (!redis) {
+        logger.warn(
+          `Cache deletion failed due to Redis unavailability: ${fullKey}`,
+          {
+            prefix: this.prefix,
+            key,
+            fullKey
+          }
+        );
+        return;
+      }
+      logger.debug(`Cache deletion started: ${fullKey}`, {
+        prefix: this.prefix,
+        key,
+        fullKey,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      await redis.del(fullKey);
+      const responseTime = Date.now() - startTime;
+      this.connectionStatus.isConnected = true;
+      this.connectionStatus.lastPingTime = /* @__PURE__ */ new Date();
+      logger.debug(`Cache deletion completed: ${fullKey}`, {
+        prefix: this.prefix,
+        key,
+        fullKey,
+        responseTime: `${responseTime}ms`
+      });
+    } catch (error) {
+      const responseTime = Date.now() - startTime;
+      const errorMessage = error instanceof Error ? error.message : "\uC54C \uC218 \uC5C6\uB294 \uC624\uB958";
+      this.connectionStatus.connectionErrors++;
+      this.connectionStatus.lastConnectionError = errorMessage;
+      this.connectionStatus.lastConnectionErrorTime = /* @__PURE__ */ new Date();
+      logger.error(`Cache deletion failed: ${fullKey}`, {
+        prefix: this.prefix,
+        key,
+        fullKey,
+        error: errorMessage,
+        responseTime: `${responseTime}ms`,
+        stack: error instanceof Error ? error.stack : void 0
+      });
+    }
+  }
+  async deletePattern(pattern) {
+    const redis = getRedisClient();
+    if (!redis) {
+      return;
+    }
+    try {
+      let cursor = 0;
+      do {
+        const result = await redis.scan(cursor, {
+          match: this.getKey(pattern),
+          count: 100
+        });
+        const nextCursor = result[0];
+        const keys = result[1];
+        cursor = typeof nextCursor === "string" ? parseInt(nextCursor, 10) : nextCursor;
+        if (Array.isArray(keys) && keys.length > 0) {
+          await redis.del(...keys);
+        }
+      } while (cursor !== 0);
+      this.connectionStatus.isConnected = true;
+      this.connectionStatus.lastPingTime = /* @__PURE__ */ new Date();
+    } catch (error) {
+      logger.error("Cache delete pattern error:", error);
+      this.connectionStatus.connectionErrors++;
+    }
+  }
+  async exists(key) {
+    const redis = getRedisClient();
+    if (!redis) {
+      return false;
+    }
+    try {
+      const result = await redis.exists(this.getKey(key));
+      this.connectionStatus.isConnected = true;
+      this.connectionStatus.lastPingTime = /* @__PURE__ */ new Date();
+      return result === 1;
+    } catch (error) {
+      logger.error("Cache exists error:", error);
+      this.connectionStatus.connectionErrors++;
+      return false;
+    }
+  }
+  async increment(key, value = 1) {
+    const redis = getRedisClient();
+    if (!redis) {
+      return 0;
+    }
+    try {
+      const result = await redis.incrby(this.getKey(key), value);
+      this.connectionStatus.isConnected = true;
+      this.connectionStatus.lastPingTime = /* @__PURE__ */ new Date();
+      return result;
+    } catch (error) {
+      logger.error("Cache increment error:", error);
+      this.connectionStatus.connectionErrors++;
+      return 0;
+    }
+  }
+  async expire(key, ttl) {
+    const redis = getRedisClient();
+    if (!redis) {
+      return;
+    }
+    try {
+      await redis.expire(this.getKey(key), ttl);
+      this.connectionStatus.isConnected = true;
+      this.connectionStatus.lastPingTime = /* @__PURE__ */ new Date();
+    } catch (error) {
+      logger.error("Cache expire error:", error);
+      this.connectionStatus.connectionErrors++;
+    }
+  }
+};
+
+export {
+  RedisCacheManager
+};

package/dist/chunk-GPBOMJSZ.js

@@ -0,0 +1,136 @@
+import {
+  AppError
+} from "./chunk-MLGO3HLS.js";
+import {
+  ERROR_CODES,
+  formatErrorMessage,
+  getHttpStatus
+} from "./chunk-Y3OTJH2S.js";
+import {
+  logger
+} from "./chunk-EZR55KV2.js";
+import {
+  __spreadProps,
+  __spreadValues
+} from "./chunk-ORMEWXMH.js";
+
+// src/error/error-handler.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." },
+  P2001: { code: 40401, message: "\uB808\uCF54\uB4DC\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4." },
+  P2002: { code: 40905, message: "\uC774\uBBF8 \uC874\uC7AC\uD558\uB294 \uB370\uC774\uD130\uC785\uB2C8\uB2E4." },
+  P2003: { code: 40001, message: "\uC678\uB798 \uD0A4 \uC81C\uC57D \uC870\uAC74 \uC704\uBC18\uC785\uB2C8\uB2E4." },
+  P2025: { code: 40401, message: "\uB808\uCF54\uB4DC\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4." }
+};
+function errorToResponse(error, requestPath) {
+  const processed = processError(error);
+  if (processed.status >= 500) {
+    logger.error("Server error", __spreadProps(__spreadValues({}, processed), { path: requestPath, stack: error instanceof Error ? error.stack : void 0 }));
+  } else if (processed.status >= 400) {
+    logger.warn("Client error", __spreadProps(__spreadValues({}, processed), { path: requestPath }));
+  }
+  return NextResponse.json(
+    { success: false, error: { code: processed.code, message: processed.message, details: processed.details } },
+    { status: processed.status }
+  );
+}
+function processError(error) {
+  var _a;
+  if (error instanceof AppError) {
+    return { code: error.code, message: error.message, status: error.status, details: error.details };
+  }
+  if (error instanceof z.ZodError) {
+    const issues = error.errors.map((e) => ({ path: e.path.join("."), message: e.message }));
+    return {
+      code: ERROR_CODES.VALIDATION_ERROR.code,
+      message: formatErrorMessage(ERROR_CODES.VALIDATION_ERROR.code, (_a = issues[0]) == null ? void 0 : _a.message),
+      status: 400,
+      details: { issues }
+    };
+  }
+  if (error instanceof Error) {
+    const prismaMatch = error.message.match(/P\d{4}/);
+    if (prismaMatch) {
+      const mapping = PRISMA_ERROR_MAP[prismaMatch[0]];
+      if (mapping) {
+        return { code: mapping.code, message: formatErrorMessage(mapping.code, mapping.message), status: getHttpStatus(mapping.code) };
+      }
+    }
+    if (error.message.toLowerCase().includes("not found")) {
+      return { code: ERROR_CODES.NOT_FOUND.code, message: formatErrorMessage(ERROR_CODES.NOT_FOUND.code), status: 404 };
+    }
+    if (error.message.toLowerCase().includes("unauthorized")) {
+      return { code: ERROR_CODES.UNAUTHORIZED.code, message: formatErrorMessage(ERROR_CODES.UNAUTHORIZED.code), status: 401 };
+    }
+    return { code: ERROR_CODES.SERVER_ERROR.code, message: formatErrorMessage(ERROR_CODES.SERVER_ERROR.code), status: 500 };
+  }
+  return { code: ERROR_CODES.INTERNAL_SERVER_ERROR.code, message: formatErrorMessage(ERROR_CODES.INTERNAL_SERVER_ERROR.code), status: 500 };
+}
+function withErrorHandler(handler) {
+  return async (request, ...args) => {
+    try {
+      return await handler(request, ...args);
+    } catch (error) {
+      return errorToResponse(error, request.nextUrl.pathname);
+    }
+  };
+}
+var ErrorResponse = {
+  // 400xx
+  validation: (message, details) => errorToResponse(AppError.validation(message, details ? __spreadValues({}, details) : void 0)),
+  badRequest: (message) => errorToResponse(AppError.badRequest(message)),
+  invalidUrl: () => errorToResponse(AppError.invalidUrl()),
+  invalidEmail: () => errorToResponse(AppError.invalidEmail()),
+  invalidAlias: () => errorToResponse(AppError.invalidAlias()),
+  // 401xx
+  unauthorized: (message) => errorToResponse(AppError.unauthorized(message)),
+  invalidToken: () => errorToResponse(AppError.invalidToken()),
+  tokenExpired: () => errorToResponse(AppError.tokenExpired()),
+  invalidCredentials: () => errorToResponse(AppError.invalidCredentials()),
+  sessionExpired: () => errorToResponse(AppError.sessionExpired()),
+  // 403xx
+  forbidden: (message) => errorToResponse(AppError.forbidden(message)),
+  emailNotVerified: () => errorToResponse(AppError.emailNotVerified()),
+  accountDisabled: () => errorToResponse(AppError.accountDisabled()),
+  accountLocked: () => errorToResponse(AppError.accountLocked()),
+  // 404xx
+  notFound: (message) => errorToResponse(AppError.notFound(message)),
+  userNotFound: () => errorToResponse(AppError.userNotFound()),
+  linkNotFound: () => errorToResponse(AppError.linkNotFound()),
+  // 409xx
+  conflict: (message) => errorToResponse(AppError.conflict(message)),
+  duplicate: (resource) => errorToResponse(AppError.duplicate(resource)),
+  emailExists: () => errorToResponse(AppError.emailExists()),
+  aliasExists: () => errorToResponse(AppError.aliasExists()),
+  // 422xx
+  businessRule: (message) => errorToResponse(AppError.businessRule(message)),
+  linkExpired: () => errorToResponse(AppError.linkExpired()),
+  linkInactive: () => errorToResponse(AppError.linkInactive()),
+  linkPasswordRequired: () => errorToResponse(AppError.linkPasswordRequired()),
+  linkPasswordIncorrect: () => errorToResponse(AppError.linkPasswordIncorrect()),
+  reservedWord: () => errorToResponse(AppError.reservedWord()),
+  quotaExceeded: () => errorToResponse(AppError.quotaExceeded()),
+  // 429xx
+  rateLimit: () => errorToResponse(AppError.rateLimit()),
+  dailyLimit: () => errorToResponse(AppError.dailyLimit()),
+  // 500xx
+  serverError: (message) => errorToResponse(AppError.serverError(message)),
+  databaseError: () => errorToResponse(AppError.databaseError()),
+  // 503xx
+  serviceUnavailable: () => errorToResponse(AppError.serviceUnavailable()),
+  externalServiceError: (service) => errorToResponse(AppError.externalServiceError(service)),
+  // 보안
+  accessBlocked: () => errorToResponse(AppError.accessBlocked()),
+  ipBlocked: () => errorToResponse(AppError.ipBlocked())
+};
+var error_handler_default = { errorToResponse, processError, withErrorHandler, ErrorResponse };
+
+export {
+  errorToResponse,
+  processError,
+  withErrorHandler,
+  ErrorResponse,
+  error_handler_default
+};

package/dist/chunk-H5I5GWAA.js

@@ -0,0 +1,94 @@
+import {
+  AppError
+} from "./chunk-MLGO3HLS.js";
+import {
+  ERROR_CODES
+} from "./chunk-Y3OTJH2S.js";
+import {
+  logger
+} from "./chunk-EZR55KV2.js";
+
+// src/middleware/rate-limit.ts
+var _rateLimitAdapter = null;
+var _adapterWarningLogged = false;
+function setRateLimitAdapter(adapter) {
+  const isInitialSetup = _rateLimitAdapter === null;
+  const previousTypes = _rateLimitAdapter ? Object.keys(_rateLimitAdapter.rateLimiters).join(", ") : "none";
+  const newTypes = Object.keys(adapter.rateLimiters).join(", ");
+  _rateLimitAdapter = adapter;
+  _adapterWarningLogged = false;
+  if (isInitialSetup) {
+    logger.info(
+      `[Rate Limit Middleware] \u2705 Initialized with types: [${newTypes}]`
+    );
+  } else {
+    logger.info(
+      `[Rate Limit Middleware] \u{1F504} Updated - Previous: [${previousTypes}] \u2192 New: [${newTypes}]`
+    );
+  }
+}
+function getRateLimitAdapter() {
+  if (!_rateLimitAdapter && !_adapterWarningLogged) {
+    logger.warn(
+      "[Rate Limit Middleware] Adapter not configured. Rate limiting is DISABLED.\nTo enable: Call setRateLimitAdapter() in instrumentation.ts"
+    );
+    _adapterWarningLogged = true;
+  }
+  return _rateLimitAdapter;
+}
+function createRateLimitMiddleware(type) {
+  return async (context, next) => {
+    const adapter = getRateLimitAdapter();
+    if (!adapter) {
+      logger.debug(`[Rate Limit Middleware] Skipping rate limit check for '${type}' (adapter not configured)`);
+      return await next();
+    }
+    if (adapter.isEnabled) {
+      const enabled = await adapter.isEnabled(type);
+      if (!enabled) {
+        return await next();
+      }
+    }
+    const ip = adapter.extractClientIp(context.request.headers);
+    const identifier = context.user ? `user:${context.user.id}` : `ip:${ip}`;
+    const limiter = adapter.rateLimiters[type];
+    if (!limiter) {
+      throw new Error(
+        `[Rate Limit Middleware] Unknown rate limit type: ${type}`
+      );
+    }
+    const result = await limiter.check(identifier);
+    context.metadata.rateLimit = {
+      limit: limiter.config.limit,
+      remaining: result.remaining,
+      reset: result.resetIn
+    };
+    if (!result.success) {
+      throw new AppError(
+        ERROR_CODES.RATE_LIMIT_EXCEEDED.code,
+        void 0,
+        // message는 에러 코드에서 자동 생성
+        {
+          resetIn: result.resetIn,
+          identifier,
+          type
+        }
+      );
+    }
+    return await next();
+  };
+}
+var rateLimitMiddleware = {
+  /** API Rate Limit (분당 120회) */
+  api: createRateLimitMiddleware("api"),
+  /** 인증 Rate Limit (시간당 40회) */
+  auth: createRateLimitMiddleware("auth"),
+  /** 관리자 Rate Limit (분당 200회) */
+  admin: createRateLimitMiddleware("admin")
+};
+
+export {
+  setRateLimitAdapter,
+  createRateLimitMiddleware,
+  rateLimitMiddleware
+};

package/dist/chunk-HGC4CCKB.js

@@ -0,0 +1,29 @@
+// src/error/logging/transports/base.ts
+var BaseTransport = class {
+  constructor(name, enabled = true) {
+    this.name = name;
+    this.enabled = enabled;
+  }
+  /**
+   * Transport 활성화 여부
+   */
+  isEnabled() {
+    return this.enabled;
+  }
+  /**
+   * Transport 활성화
+   */
+  enable() {
+    this.enabled = true;
+  }
+  /**
+   * Transport 비활성화
+   */
+  disable() {
+    this.enabled = false;
+  }
+};
+
+export {
+  BaseTransport
+};