@withwiz/toolkit 0.1.0

package/dist/auth/types/index.d.ts

@@ -0,0 +1,213 @@
+/**
+ * Shared Auth Types
+ *
+ * 프레임워크 독립적인 인증 타입 정의
+ * Next.js, Express, Fastify 등 어디서나 사용 가능
+ */
+export interface Logger {
+    debug(message: string, meta?: any): void;
+    info(message: string, meta?: any): void;
+    warn(message: string, meta?: any): void;
+    error(message: string, meta?: any): void;
+}
+export declare enum UserRole {
+    USER = "USER",
+    ADMIN = "ADMIN"
+}
+export interface JWTPayload {
+    id: string;
+    userId: string;
+    email: string;
+    role: UserRole;
+    emailVerified?: Date | null;
+    tokenType?: 'access' | 'refresh';
+    iat?: number;
+    exp?: number;
+}
+export interface TokenPair {
+    accessToken: string;
+    refreshToken: string;
+}
+export interface JWTConfig {
+    secret: string;
+    accessTokenExpiry: string;
+    refreshTokenExpiry: string;
+    algorithm: 'HS256' | 'HS384' | 'HS512';
+}
+export declare enum OAuthProvider {
+    GOOGLE = "google",
+    GITHUB = "github"
+}
+export interface OAuthUserInfo {
+    id: string;
+    email: string;
+    name: string | null;
+    image: string | null;
+    emailVerified: boolean;
+}
+export interface OAuthTokenResponse {
+    access_token: string;
+    token_type: string;
+    expires_in?: number;
+    refresh_token?: string;
+    scope?: string;
+}
+export interface OAuthConfig {
+    google?: {
+        clientId: string;
+        clientSecret: string;
+        redirectUri: string;
+    };
+    github?: {
+        clientId: string;
+        clientSecret: string;
+        redirectUri: string;
+    };
+}
+export declare enum PasswordStrength {
+    VERY_WEAK = "VERY_WEAK",
+    WEAK = "WEAK",
+    MEDIUM = "MEDIUM",
+    STRONG = "STRONG",
+    VERY_STRONG = "VERY_STRONG"
+}
+export interface PasswordValidationResult {
+    isValid: boolean;
+    strength: PasswordStrength;
+    errors: string[];
+}
+export interface PasswordConfig {
+    minLength: number;
+    maxLength: number;
+    requireNumber: boolean;
+    requireUppercase: boolean;
+    requireLowercase: boolean;
+    requireSpecialChar: boolean;
+    bcryptRounds: number;
+}
+export declare enum TokenType {
+    EMAIL_VERIFICATION = "EMAIL_VERIFICATION",
+    PASSWORD_RESET = "PASSWORD_RESET",
+    MAGIC_LINK = "MAGIC_LINK"
+}
+export interface BaseUser {
+    id: string;
+    email: string;
+    name: string | null;
+    role: UserRole;
+    emailVerified: Date | null;
+    isActive: boolean;
+    image: string | null;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface UserRepository {
+    findById(id: string): Promise<BaseUser | null>;
+    findByEmail(email: string): Promise<BaseUser | null>;
+    create(data: CreateUserData): Promise<BaseUser>;
+    update(id: string, data: UpdateUserData): Promise<BaseUser>;
+    delete(id: string): Promise<void>;
+    updateLastLoginAt(id: string): Promise<void>;
+    verifyEmail(email: string): Promise<void>;
+}
+export interface CreateUserData {
+    email: string;
+    password?: string | null;
+    name?: string | null;
+    role?: UserRole;
+    emailVerified?: Date | null;
+    image?: string | null;
+}
+export interface UpdateUserData {
+    email?: string;
+    password?: string;
+    name?: string | null;
+    role?: UserRole;
+    emailVerified?: Date | null;
+    isActive?: boolean;
+    image?: string | null;
+}
+export interface OAuthAccount {
+    id: string;
+    userId: string;
+    provider: OAuthProvider;
+    providerAccountId: string;
+    accessToken: string | null;
+    refreshToken: string | null;
+    expiresAt: Date | null;
+    tokenType: string | null;
+    scope: string | null;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface OAuthAccountRepository {
+    findByProvider(provider: OAuthProvider, providerAccountId: string): Promise<OAuthAccount | null>;
+    findByUserId(userId: string): Promise<OAuthAccount[]>;
+    create(data: CreateOAuthAccountData): Promise<OAuthAccount>;
+    update(id: string, data: UpdateOAuthAccountData): Promise<OAuthAccount>;
+    delete(id: string): Promise<void>;
+}
+export interface CreateOAuthAccountData {
+    userId: string;
+    provider: OAuthProvider;
+    providerAccountId: string;
+    accessToken?: string | null;
+    refreshToken?: string | null;
+    expiresAt?: Date | null;
+    tokenType?: string | null;
+    scope?: string | null;
+}
+export interface UpdateOAuthAccountData {
+    accessToken?: string | null;
+    refreshToken?: string | null;
+    expiresAt?: Date | null;
+    tokenType?: string | null;
+    scope?: string | null;
+}
+export interface EmailToken {
+    id: string;
+    email: string;
+    token: string;
+    type: TokenType;
+    expires: Date;
+    used: boolean;
+    createdAt: Date;
+}
+export interface EmailTokenRepository {
+    create(email: string, token: string, type: TokenType, expiresAt: Date): Promise<EmailToken>;
+    findByEmailAndToken(email: string, token: string, type: TokenType): Promise<EmailToken | null>;
+    delete(email: string, token: string, type: TokenType): Promise<void>;
+    deleteExpired(): Promise<void>;
+    markAsUsed(id: string): Promise<void>;
+}
+export interface EmailConfig {
+    from: string;
+    provider: 'smtp' | 'sendgrid' | 'mailgun' | 'resend';
+    verificationTokenExpiry: number;
+    passwordResetTokenExpiry: number;
+    magicLinkTokenExpiry: number;
+}
+export interface EmailSender {
+    sendVerificationEmail(email: string, token: string): Promise<void>;
+    sendPasswordResetEmail(email: string, token: string): Promise<void>;
+    sendMagicLinkEmail(email: string, token: string): Promise<void>;
+    sendWelcomeEmail(email: string, name: string): Promise<void>;
+}
+export interface AuthConfig {
+    jwt: JWTConfig;
+    password: PasswordConfig;
+    oauth?: OAuthConfig;
+    email?: EmailConfig;
+    features: {
+        emailVerificationRequired: boolean;
+        magicLinkEnabled: boolean;
+        oauthEnabled: boolean;
+        passwordResetEnabled: boolean;
+    };
+    urls: {
+        baseUrl: string;
+        loginUrl: string;
+        callbackUrl: string;
+    };
+    logger?: Logger;
+}

package/dist/auth/types/index.js

@@ -0,0 +1,13 @@
+import {
+  OAuthProvider,
+  PasswordStrength,
+  TokenType,
+  UserRole
+} from "../../chunk-6D3HHYER.js";
+import "../../chunk-ORMEWXMH.js";
+export {
+  OAuthProvider,
+  PasswordStrength,
+  TokenType,
+  UserRole
+};

package/dist/cache/cache-config.d.ts

@@ -0,0 +1,73 @@
+export interface CacheOptions {
+    ttl?: number;
+    prefix?: string;
+}
+/**
+ * 통일된 캐시 설정 유틸리티
+ * getENV().CACHE를 통해 중앙화된 환경변수에서 값을 가져옴
+ */
+export declare const getCacheConfig: {
+    analytics: {
+        enabled: () => boolean;
+        duration: () => number;
+    };
+    user: {
+        enabled: () => boolean;
+        duration: () => number;
+    };
+    geoip: {
+        enabled: () => boolean;
+        duration: () => number;
+    };
+    settings: {
+        enabled: () => boolean;
+        duration: () => number;
+    };
+    reservedWords: {
+        enabled: () => boolean;
+        duration: () => number;
+    };
+    alias: {
+        enabled: () => boolean;
+        duration: () => number;
+    };
+    community: {
+        enabled: () => boolean;
+        duration: () => number;
+    };
+    link: {
+        enabled: () => boolean;
+        duration: () => number;
+    };
+    rateLimit: {
+        enabled: () => boolean;
+        duration: () => number;
+    };
+    urlToken: {
+        enabled: () => boolean;
+        duration: () => number;
+    };
+    apiKey: {
+        enabled: () => boolean;
+        duration: () => number;
+    };
+    apiConfig: {
+        enabled: () => boolean;
+        duration: () => number;
+    };
+};
+/**
+ * @deprecated getCacheConfig.xxx.duration()을 사용하세요.
+ * 예: getCacheConfig.analytics.duration()
+ */
+export declare const getCacheTTL: {
+    settings: () => number;
+    reservedWords: () => number;
+    alias: () => number;
+    user: () => number;
+    analytics: () => number;
+    geoip: () => number;
+    community: () => number;
+    link: () => number;
+    default: () => number;
+};

package/dist/cache/cache-config.js

@@ -0,0 +1,12 @@
+import {
+  getCacheConfig,
+  getCacheTTL
+} from "../chunk-TXGNSECL.js";
+import "../chunk-I47QEDTX.js";
+import "../chunk-EZR55KV2.js";
+import "../chunk-IQQKKUAV.js";
+import "../chunk-ORMEWXMH.js";
+export {
+  getCacheConfig,
+  getCacheTTL
+};

package/dist/cache/cache-defaults.d.ts

@@ -0,0 +1,141 @@
+/**
+ * Cache Default Constants
+ *
+ * 캐시 관련 기본값 상수 정의
+ * 환경 변수가 설정되지 않았을 때 사용되는 폴백 값들
+ */
+/** 1분 (초) */
+export declare const ONE_MINUTE = 60;
+/** 5분 (초) */
+export declare const FIVE_MINUTES = 300;
+/** 10분 (초) */
+export declare const TEN_MINUTES = 600;
+/** 15분 (초) */
+export declare const FIFTEEN_MINUTES = 900;
+/** 30분 (초) */
+export declare const THIRTY_MINUTES = 1800;
+/** 1시간 (초) */
+export declare const ONE_HOUR = 3600;
+/** 24시간 (초) */
+export declare const ONE_DAY = 86400;
+/** 30일 (초) */
+export declare const THIRTY_DAYS = 2592000;
+export declare const INMEMORY_CACHE_DEFAULTS: {
+    /** 최대 캐시 항목 수 */
+    readonly MAX_SIZE: 100000;
+    /** 최대 메모리 사용량 (MB) */
+    readonly MAX_MB: 200;
+    /** 제거 정책: 'lru' | 'fifo' | 'ttl' */
+    readonly EVICTION: "lru";
+    /** 정리 간격 (밀리초) */
+    readonly CLEANUP_INTERVAL: 60000;
+};
+export declare const CACHE_TTL_DEFAULTS: {
+    /** 기본 TTL (1시간) */
+    readonly DEFAULT: 3600;
+    /** 짧은 TTL (5분) - 자주 변경되는 데이터 */
+    readonly SHORT: 300;
+    /** 긴 TTL (24시간) - 거의 변경되지 않는 데이터 */
+    readonly LONG: 86400;
+    /** GeoIP TTL (30일) - IP 위치 정보는 거의 변경되지 않음 */
+    readonly GEOIP: 2592000;
+    /** 설정 TTL (1시간) */
+    readonly SETTINGS: 3600;
+    /** 분석 데이터 TTL (30분) */
+    readonly ANALYTICS: 1800;
+    /** 사용자 데이터 TTL (30분) */
+    readonly USER: 1800;
+    /** 링크 데이터 TTL (30분) */
+    readonly LINK: 1800;
+    /** 별칭 TTL (5분) - 자주 확인되는 데이터 */
+    readonly ALIAS: 300;
+    /** 커뮤니티 TTL (15분) */
+    readonly COMMUNITY: 900;
+    /** 예약어 TTL (30분) */
+    readonly RESERVED_WORDS: 1800;
+};
+export declare const CACHE_DURATION_DEFAULTS: {
+    /** 분석 데이터 (30분) */
+    readonly ANALYTICS: 1800;
+    /** 사용자 데이터 (10분) */
+    readonly USER: 600;
+    /** GeoIP 데이터 (30일) */
+    readonly GEOIP: 2592000;
+    /** 설정 데이터 (30분) */
+    readonly SETTINGS: 1800;
+    /** 예약어 데이터 (30분) */
+    readonly RESERVED_WORDS: 1800;
+    /** 별칭 데이터 (5분) */
+    readonly ALIAS: 300;
+    /** 커뮤니티 데이터 (15분) */
+    readonly COMMUNITY: 900;
+    /** 링크 데이터 (30분) */
+    readonly LINK: 1800;
+    /** Rate Limit (1분) */
+    readonly RATE_LIMIT: 60;
+    /** URL 토큰 (5분) */
+    readonly URL_TOKEN: 300;
+    /** API 키 (5분) */
+    readonly API_KEY: 300;
+    /** API 설정 (10분) */
+    readonly API_CONFIG: 600;
+};
+export declare const CACHE_FALLBACK_DEFAULTS: {
+    /** 전역 Redis 에러 임계값 (이 값 이상이면 즉시 전역 비활성화) */
+    readonly REDIS_ERROR_THRESHOLD_GLOBAL: 1;
+    /** 인스턴스별 Redis 에러 임계값 (이 값 이상이면 해당 인스턴스만 일시 비활성화) */
+    readonly REDIS_ERROR_THRESHOLD_LOCAL: 5;
+    /** Redis 재연결 시도 간격 (밀리초) */
+    readonly REDIS_RECONNECT_INTERVAL: 30000;
+    /** Redis 에러 시 인메모리 폴백 허용 여부 */
+    readonly FALLBACK_ON_REDIS_ERROR: true;
+    /** hybrid 모드에서 인메모리에도 저장 여부 */
+    readonly WRITE_TO_MEMORY: true;
+};
+export declare const CACHE_HEALTH_DEFAULTS: {
+    /** 건강상태 판단: 에러율 임계값 (%) - 이 값 이상이면 unhealthy */
+    readonly ERROR_RATE_THRESHOLD: 10;
+    /** 건강상태 판단: 히트율 임계값 (%) - 이 값 미만이면 unhealthy */
+    readonly HIT_RATE_THRESHOLD: 50;
+    /** 성능 리포트: 권장 히트율 (%) - 이 값 미만이면 TTL 조정 권장 */
+    readonly REPORT_HIT_RATE_THRESHOLD: 70;
+    /** 성능 리포트: 응답시간 임계값 (ms) - 이 값 초과 시 성능 확인 권장 */
+    readonly REPORT_RESPONSE_TIME_THRESHOLD: 500;
+    /** 성능 리포트: 무효화 빈도 임계값 (/분) - 이 값 초과 시 최적화 권장 */
+    readonly REPORT_INVALIDATION_THRESHOLD: 100;
+    /** 성능 리포트: 최소 요청 수 - 이 값 미만이면 리포트 판단 생략 */
+    readonly REPORT_MIN_REQUESTS: 100;
+};
+export declare const CACHE_ENV_VARS: {
+    readonly CACHE_ENABLED: "CACHE_ENABLED";
+    readonly CACHE_REDIS_ENABLED: "CACHE_REDIS_ENABLED";
+    readonly CACHE_INMEMORY_ENABLED: "CACHE_INMEMORY_ENABLED";
+    readonly CACHE_INMEMORY_MAX_SIZE: "CACHE_INMEMORY_MAX_SIZE";
+    readonly CACHE_INMEMORY_MAX_MB: "CACHE_INMEMORY_MAX_MB";
+    readonly CACHE_INMEMORY_EVICTION: "CACHE_INMEMORY_EVICTION";
+    readonly CACHE_INMEMORY_CLEANUP_INTERVAL: "CACHE_INMEMORY_CLEANUP_INTERVAL";
+    readonly UPSTASH_REDIS_REST_URL: "UPSTASH_REDIS_REST_URL";
+    readonly UPSTASH_REDIS_REST_TOKEN: "UPSTASH_REDIS_REST_TOKEN";
+    readonly CACHE_TTL_DEFAULT: "CACHE_TTL_DEFAULT";
+    readonly CACHE_TTL_SHORT: "CACHE_TTL_SHORT";
+    readonly CACHE_TTL_LONG: "CACHE_TTL_LONG";
+    readonly CACHE_TTL_GEOIP: "CACHE_TTL_GEOIP";
+    readonly CACHE_TTL_SETTINGS: "CACHE_TTL_SETTINGS";
+    readonly CACHE_TTL_ANALYTICS: "CACHE_TTL_ANALYTICS";
+    readonly CACHE_TTL_USER: "CACHE_TTL_USER";
+    readonly CACHE_TTL_LINK: "CACHE_TTL_LINK";
+    readonly CACHE_TTL_ALIAS: "CACHE_TTL_ALIAS";
+    readonly CACHE_TTL_COMMUNITY: "CACHE_TTL_COMMUNITY";
+    readonly CACHE_TTL_RESERVED_WORDS: "CACHE_TTL_RESERVED_WORDS";
+    readonly CACHE_REDIS_ERROR_THRESHOLD_GLOBAL: "CACHE_REDIS_ERROR_THRESHOLD_GLOBAL";
+    readonly CACHE_REDIS_ERROR_THRESHOLD_LOCAL: "CACHE_REDIS_ERROR_THRESHOLD_LOCAL";
+    readonly CACHE_REDIS_RECONNECT_INTERVAL: "CACHE_REDIS_RECONNECT_INTERVAL";
+    readonly CACHE_FALLBACK_ON_REDIS_ERROR: "CACHE_FALLBACK_ON_REDIS_ERROR";
+    readonly CACHE_WRITE_TO_MEMORY: "CACHE_WRITE_TO_MEMORY";
+    readonly CACHE_HEALTH_ERROR_RATE_THRESHOLD: "CACHE_HEALTH_ERROR_RATE_THRESHOLD";
+    readonly CACHE_HEALTH_HIT_RATE_THRESHOLD: "CACHE_HEALTH_HIT_RATE_THRESHOLD";
+    readonly CACHE_REPORT_HIT_RATE_THRESHOLD: "CACHE_REPORT_HIT_RATE_THRESHOLD";
+    readonly CACHE_REPORT_RESPONSE_TIME_THRESHOLD: "CACHE_REPORT_RESPONSE_TIME_THRESHOLD";
+    readonly CACHE_REPORT_INVALIDATION_THRESHOLD: "CACHE_REPORT_INVALIDATION_THRESHOLD";
+    readonly CACHE_REPORT_MIN_REQUESTS: "CACHE_REPORT_MIN_REQUESTS";
+};

package/dist/cache/cache-defaults.js

@@ -0,0 +1,33 @@
+import {
+  CACHE_DURATION_DEFAULTS,
+  CACHE_ENV_VARS,
+  CACHE_FALLBACK_DEFAULTS,
+  CACHE_HEALTH_DEFAULTS,
+  CACHE_TTL_DEFAULTS,
+  FIFTEEN_MINUTES,
+  FIVE_MINUTES,
+  INMEMORY_CACHE_DEFAULTS,
+  ONE_DAY,
+  ONE_HOUR,
+  ONE_MINUTE,
+  TEN_MINUTES,
+  THIRTY_DAYS,
+  THIRTY_MINUTES
+} from "../chunk-IQQKKUAV.js";
+import "../chunk-ORMEWXMH.js";
+export {
+  CACHE_DURATION_DEFAULTS,
+  CACHE_ENV_VARS,
+  CACHE_FALLBACK_DEFAULTS,
+  CACHE_HEALTH_DEFAULTS,
+  CACHE_TTL_DEFAULTS,
+  FIFTEEN_MINUTES,
+  FIVE_MINUTES,
+  INMEMORY_CACHE_DEFAULTS,
+  ONE_DAY,
+  ONE_HOUR,
+  ONE_MINUTE,
+  TEN_MINUTES,
+  THIRTY_DAYS,
+  THIRTY_MINUTES
+};

package/dist/cache/cache-env.d.ts

@@ -0,0 +1,75 @@
+import type { ISharedEnvConfig, IRawEnv } from '@withwiz/types/env';
+/**
+ * 기본 환경 설정 (fallback용)
+ * process.env에서 직접 읽되, 타입 안전하게 처리
+ */
+export declare function getDefaultConfig(): ISharedEnvConfig;
+/**
+ * 현재 환경 설정 가져오기 (주입된 설정 또는 기본값)
+ */
+export declare function getConfig(): ISharedEnvConfig;
+export declare const getEnv: () => IRawEnv;
+export declare const getENV: () => {
+    REDIS: import("@withwiz/types/env").IRedisEnv;
+    CACHE: import("@withwiz/types/env").ICacheEnv;
+};
+declare global {
+    var __cacheInitialized: boolean | undefined;
+}
+/**
+ * 캐시 모듈 초기화 (외부에서 환경 설정 주입)
+ *
+ * @example
+ * ```typescript
+ * import { initializeCache } from '@withwiz/cache/cache';
+ * import { env, ENV, isCacheEnabled, isRedisAvailable } from '<your-project>/env';
+ *
+ * initializeCache({ env, ENV, isCacheEnabled, isRedisAvailable });
+ * ```
+ */
+export declare function initializeCache(config: ISharedEnvConfig): void;
+export declare const isCacheEnabled: () => boolean;
+export declare function validateRedisEnvironment(): {
+    isValid: boolean;
+    errors: string[];
+};
+/**
+ * 캐시 폴백 설정 인터페이스
+ */
+export interface CacheFallbackConfig {
+    /** 전역 Redis 에러 임계값 */
+    redisErrorThresholdGlobal: number;
+    /** 인스턴스별 Redis 에러 임계값 */
+    redisErrorThresholdLocal: number;
+    /** Redis 재연결 간격 (ms) */
+    redisReconnectInterval: number;
+    /** Redis 에러 시 인메모리 폴백 허용 여부 */
+    fallbackOnRedisError: boolean;
+    /** hybrid 모드에서 인메모리에도 저장 여부 */
+    writeToMemory: boolean;
+}
+/**
+ * 캐시 폴백 설정 가져오기
+ */
+export declare function getCacheFallbackConfig(): CacheFallbackConfig;
+/**
+ * 캐시 건강상태 설정 인터페이스
+ */
+export interface CacheHealthConfig {
+    /** 건강상태 판단: 에러율 임계값 (%) */
+    errorRateThreshold: number;
+    /** 건강상태 판단: 히트율 임계값 (%) */
+    hitRateThreshold: number;
+    /** 성능 리포트: 권장 히트율 (%) */
+    reportHitRateThreshold: number;
+    /** 성능 리포트: 응답시간 임계값 (ms) */
+    reportResponseTimeThreshold: number;
+    /** 성능 리포트: 무효화 빈도 임계값 (/분) */
+    reportInvalidationThreshold: number;
+    /** 성능 리포트: 최소 요청 수 */
+    reportMinRequests: number;
+}
+/**
+ * 캐시 건강상태 설정 가져오기
+ */
+export declare function getCacheHealthConfig(): CacheHealthConfig;

package/dist/cache/cache-env.js

@@ -0,0 +1,25 @@
+import {
+  getCacheFallbackConfig,
+  getCacheHealthConfig,
+  getConfig,
+  getDefaultConfig,
+  getENV,
+  getEnv,
+  initializeCache,
+  isCacheEnabled,
+  validateRedisEnvironment
+} from "../chunk-I47QEDTX.js";
+import "../chunk-EZR55KV2.js";
+import "../chunk-IQQKKUAV.js";
+import "../chunk-ORMEWXMH.js";
+export {
+  getCacheFallbackConfig,
+  getCacheHealthConfig,
+  getConfig,
+  getDefaultConfig,
+  getENV,
+  getEnv,
+  initializeCache,
+  isCacheEnabled,
+  validateRedisEnvironment
+};

package/dist/cache/cache-factory.d.ts

@@ -0,0 +1,34 @@
+import type { CacheBackendType } from '@withwiz/types/env';
+import { RedisCacheManager } from './redis-cache-manager';
+import { NoopCacheManager } from './noop-cache-manager';
+import { InMemoryCacheManager } from './inmemory-cache-manager';
+import { HybridCacheManager } from './hybrid-cache-manager';
+export { isRedisGloballyDisabled, getRedisGlobalStatus } from './cache-redis';
+/**
+ * 효과적인 캐시 백엔드 결정
+ *
+ * CACHE_REDIS_ENABLED + CACHE_INMEMORY_ENABLED 조합으로 백엔드 결정:
+ * - true + true → 'hybrid' (Redis 기본, InMemory 폴백)
+ * - true + false → 'redis' (Redis만 사용)
+ * - false + true → 'memory' (InMemory만 사용)
+ * - false + false → 'none' (NoopCache, 경고 로그)
+ *
+ * 전역적으로 Redis가 비활성화된 경우:
+ * - 'hybrid' → 'memory'로 폴백
+ * - 'redis' → 'memory'로 폴백 (inmemory가 활성화된 경우)
+ *
+ * @returns 'hybrid' | 'redis' | 'memory' | 'none'
+ */
+export declare function getEffectiveCacheBackend(): CacheBackendType | 'none';
+/**
+ * 캐시 매니저 인스턴스 생성 함수 (지연 초기화)
+ */
+export declare function getCacheManager(prefix: string): RedisCacheManager | HybridCacheManager | InMemoryCacheManager | NoopCacheManager;
+/**
+ * 기본 범용 캐시
+ */
+export declare const cache: RedisCacheManager | NoopCacheManager | InMemoryCacheManager | HybridCacheManager;
+/**
+ * GeoIP 캐시 (범용)
+ */
+export declare const geoCache: RedisCacheManager | NoopCacheManager | InMemoryCacheManager | HybridCacheManager;

package/dist/cache/cache-factory.js

@@ -0,0 +1,28 @@
+import {
+  cache,
+  geoCache,
+  getCacheManager,
+  getEffectiveCacheBackend
+} from "../chunk-AIHQBQ3E.js";
+import "../chunk-HV3DGSSH.js";
+import "../chunk-Z4D4CMDA.js";
+import "../chunk-SS56XFLI.js";
+import "../chunk-Q7IP4JMW.js";
+import "../chunk-GL2NANFH.js";
+import "../chunk-TXGNSECL.js";
+import {
+  getRedisGlobalStatus,
+  isRedisGloballyDisabled
+} from "../chunk-6LTZCXNC.js";
+import "../chunk-I47QEDTX.js";
+import "../chunk-EZR55KV2.js";
+import "../chunk-IQQKKUAV.js";
+import "../chunk-ORMEWXMH.js";
+export {
+  cache,
+  geoCache,
+  getCacheManager,
+  getEffectiveCacheBackend,
+  getRedisGlobalStatus,
+  isRedisGloballyDisabled
+};