@withwiz/toolkit 0.4.1 → 0.5.1

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

@@ -10,15 +10,11 @@ export interface Logger {
     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;
+    role: string;
     emailVerified?: Date | null;
     tokenType?: 'access' | 'refresh';
     iat?: number;
@@ -34,10 +30,12 @@ export interface JWTConfig {
     refreshTokenExpiry: string;
     algorithm: 'HS256' | 'HS384' | 'HS512';
 }
-export declare enum OAuthProvider {
-    GOOGLE = "google",
-    GITHUB = "github"
-}
+export declare const OAUTH_PROVIDERS: {
+    readonly GOOGLE: "google";
+    readonly GITHUB: "github";
+    readonly KAKAO: "kakao";
+};
+export type OAuthProviderName = typeof OAUTH_PROVIDERS[keyof typeof OAUTH_PROVIDERS];
 export interface OAuthUserInfo {
     id: string;
     email: string;
@@ -52,17 +50,19 @@ export interface OAuthTokenResponse {
     refresh_token?: string;
     scope?: string;
 }
+export interface OAuthProviderConfig {
+    clientId: string;
+    clientSecret: string;
+    redirectUri: string;
+}
 export interface OAuthConfig {
-    google?: {
-        clientId: string;
-        clientSecret: string;
-        redirectUri: string;
-    };
-    github?: {
-        clientId: string;
-        clientSecret: string;
-        redirectUri: string;
-    };
+    providers: Record<string, OAuthProviderConfig>;
+}
+export interface IOAuthProviderAdapter {
+    readonly name: string;
+    getLoginUrl(config: OAuthProviderConfig, state?: string): string;
+    exchangeCodeForToken(config: OAuthProviderConfig, code: string): Promise<OAuthTokenResponse>;
+    getUserInfo(accessToken: string): Promise<OAuthUserInfo>;
 }
 export declare enum PasswordStrength {
     VERY_WEAK = "VERY_WEAK",
@@ -93,13 +93,13 @@ export declare enum TokenType {
 export interface BaseUser {
     id: string;
     email: string;
-    name: string | null;
-    role: UserRole;
-    emailVerified: Date | null;
-    isActive: boolean;
-    image: string | null;
-    createdAt: Date;
-    updatedAt: Date;
+    name?: string | null;
+    role?: string;
+    emailVerified?: Date | null;
+    isActive?: boolean;
+    image?: string | null;
+    createdAt?: Date;
+    updatedAt?: Date;
 }
 export interface UserRepository {
     findById(id: string): Promise<BaseUser | null>;
@@ -114,7 +114,7 @@ export interface CreateUserData {
     email: string;
     password?: string | null;
     name?: string | null;
-    role?: UserRole;
+    role?: string;
     emailVerified?: Date | null;
     image?: string | null;
 }
@@ -122,7 +122,7 @@ export interface UpdateUserData {
     email?: string;
     password?: string;
     name?: string | null;
-    role?: UserRole;
+    role?: string;
     emailVerified?: Date | null;
     isActive?: boolean;
     image?: string | null;
@@ -130,7 +130,7 @@ export interface UpdateUserData {
 export interface OAuthAccount {
     id: string;
     userId: string;
-    provider: OAuthProvider;
+    provider: string;
     providerAccountId: string;
     accessToken: string | null;
     refreshToken: string | null;
@@ -141,7 +141,7 @@ export interface OAuthAccount {
     updatedAt: Date;
 }
 export interface OAuthAccountRepository {
-    findByProvider(provider: OAuthProvider, providerAccountId: string): Promise<OAuthAccount | null>;
+    findByProvider(provider: string, providerAccountId: string): Promise<OAuthAccount | null>;
     findByUserId(userId: string): Promise<OAuthAccount[]>;
     create(data: CreateOAuthAccountData): Promise<OAuthAccount>;
     update(id: string, data: UpdateOAuthAccountData): Promise<OAuthAccount>;
@@ -149,7 +149,7 @@ export interface OAuthAccountRepository {
 }
 export interface CreateOAuthAccountData {
     userId: string;
-    provider: OAuthProvider;
+    provider: string;
     providerAccountId: string;
     accessToken?: string | null;
     refreshToken?: string | null;

package/dist/auth/types/index.js

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

package/dist/chunk-2QQNL4ND.js

@@ -0,0 +1,62 @@
+import {
+  OAuthError
+} from "./chunk-AIH3F7JV.js";
+
+// src/auth/core/oauth/providers/kakao.ts
+var KakaoOAuthProvider = class {
+  constructor() {
+    this.name = "kakao";
+  }
+  getLoginUrl(config, state) {
+    const params = new URLSearchParams({
+      client_id: config.clientId,
+      redirect_uri: config.redirectUri,
+      response_type: "code",
+      scope: "profile_nickname profile_image account_email"
+    });
+    if (state) {
+      params.set("state", state);
+    }
+    return `https://kauth.kakao.com/oauth/authorize?${params.toString()}`;
+  }
+  async exchangeCodeForToken(config, code) {
+    const response = await fetch("https://kauth.kakao.com/oauth/token", {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: new URLSearchParams({
+        client_id: config.clientId,
+        client_secret: config.clientSecret,
+        code,
+        grant_type: "authorization_code",
+        redirect_uri: config.redirectUri
+      })
+    });
+    if (!response.ok) {
+      const errorData = await response.text();
+      throw new OAuthError(`Kakao token exchange failed: ${errorData}`, "TOKEN_EXCHANGE_FAILED");
+    }
+    return response.json();
+  }
+  async getUserInfo(accessToken) {
+    const response = await fetch("https://kapi.kakao.com/v2/user/me", {
+      headers: { Authorization: `Bearer ${accessToken}` }
+    });
+    if (!response.ok) {
+      throw new OAuthError("Failed to get Kakao user info", "USER_INFO_FAILED");
+    }
+    const data = await response.json();
+    const account = data.kakao_account || {};
+    const profile = account.profile || {};
+    return {
+      id: data.id.toString(),
+      email: account.email,
+      name: profile.nickname || null,
+      image: profile.profile_image_url || null,
+      emailVerified: account.is_email_verified || false
+    };
+  }
+};
+
+export {
+  KakaoOAuthProvider
+};

package/dist/chunk-6PGZTY4N.js

@@ -0,0 +1,30 @@
+import {
+  ConfigurationError
+} from "./chunk-2QH66EVQ.js";
+
+// src/config/registry.ts
+function initConfig(entries) {
+  if (globalThis.__withwiz_config) return;
+  globalThis.__withwiz_config = Object.freeze(entries);
+}
+var config = new Proxy({}, {
+  get(_target, prop, _receiver) {
+    const store = globalThis.__withwiz_config;
+    if (!store) {
+      throw new ConfigurationError("Config", "Not initialized. Call initConfig() first.");
+    }
+    return store[prop];
+  },
+  set() {
+    throw new TypeError("config is read-only");
+  }
+});
+function resetConfig() {
+  globalThis.__withwiz_config = void 0;
+}
+
+export {
+  initConfig,
+  config,
+  resetConfig
+};

package/dist/chunk-GBLNXNEH.js

@@ -0,0 +1,64 @@
+import {
+  OAuthError
+} from "./chunk-AIH3F7JV.js";
+
+// src/auth/core/oauth/providers/github.ts
+var GitHubOAuthProvider = class {
+  constructor() {
+    this.name = "github";
+  }
+  getLoginUrl(config, state) {
+    const params = new URLSearchParams({
+      client_id: config.clientId,
+      redirect_uri: config.redirectUri,
+      scope: "read:user user:email"
+    });
+    if (state) {
+      params.set("state", state);
+    }
+    return `https://github.com/login/oauth/authorize?${params.toString()}`;
+  }
+  async exchangeCodeForToken(config, code) {
+    const response = await fetch("https://github.com/login/oauth/access_token", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json"
+      },
+      body: JSON.stringify({
+        client_id: config.clientId,
+        client_secret: config.clientSecret,
+        code,
+        redirect_uri: config.redirectUri
+      })
+    });
+    if (!response.ok) {
+      const errorData = await response.text();
+      throw new OAuthError(`GitHub token exchange failed: ${errorData}`, "TOKEN_EXCHANGE_FAILED");
+    }
+    return response.json();
+  }
+  async getUserInfo(accessToken) {
+    const response = await fetch("https://api.github.com/user", {
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        "User-Agent": "Auth-Module"
+      }
+    });
+    if (!response.ok) {
+      throw new OAuthError("Failed to get GitHub user info", "USER_INFO_FAILED");
+    }
+    const data = await response.json();
+    return {
+      id: data.id.toString(),
+      email: data.email,
+      name: data.name || null,
+      image: data.avatar_url || null,
+      emailVerified: !!data.email
+    };
+  }
+};
+
+export {
+  GitHubOAuthProvider
+};

package/dist/chunk-HZLJYEOO.js

@@ -0,0 +1,92 @@
+import {
+  KakaoOAuthProvider
+} from "./chunk-2QQNL4ND.js";
+import {
+  GitHubOAuthProvider
+} from "./chunk-GBLNXNEH.js";
+import {
+  GoogleOAuthProvider
+} from "./chunk-RVL5ROWQ.js";
+import {
+  OAuthError
+} from "./chunk-AIH3F7JV.js";
+
+// src/auth/core/oauth/index.ts
+var OAuthManager = class {
+  constructor(config, logger) {
+    this.providers = /* @__PURE__ */ new Map();
+    this.config = config;
+    this.logger = logger;
+    this.registerProvider(new GoogleOAuthProvider());
+    this.registerProvider(new GitHubOAuthProvider());
+    this.registerProvider(new KakaoOAuthProvider());
+  }
+  /**
+   * 프로바이더 어댑터 등록
+   */
+  registerProvider(provider) {
+    this.providers.set(provider.name, provider);
+    this.logger.debug(`OAuth provider registered: ${provider.name}`);
+  }
+  /**
+   * OAuth 로그인 URL 생성
+   */
+  getLoginUrl(providerName, state) {
+    const provider = this.getProvider(providerName);
+    const config = this.getProviderConfig(providerName);
+    return provider.getLoginUrl(config, state);
+  }
+  /**
+   * 인증 코드를 액세스 토큰으로 교환
+   */
+  async exchangeCodeForToken(providerName, code) {
+    const provider = this.getProvider(providerName);
+    const config = this.getProviderConfig(providerName);
+    try {
+      const tokenResponse = await provider.exchangeCodeForToken(config, code);
+      this.logger.debug(`${providerName} token exchange successful`);
+      return tokenResponse.access_token;
+    } catch (error) {
+      this.logger.error(`${providerName} token exchange error`, { error: error.message });
+      throw error instanceof OAuthError ? error : new OAuthError(`${providerName} token exchange failed`, "TOKEN_EXCHANGE_FAILED");
+    }
+  }
+  /**
+   * 사용자 정보 가져오기
+   */
+  async getUserInfo(providerName, accessToken) {
+    const provider = this.getProvider(providerName);
+    try {
+      const userInfo = await provider.getUserInfo(accessToken);
+      this.logger.debug(`${providerName} user info retrieved`, { userId: userInfo.id, email: userInfo.email });
+      return userInfo;
+    } catch (error) {
+      this.logger.error(`${providerName} user info error`, { error: error.message });
+      throw error instanceof OAuthError ? error : new OAuthError(`Failed to retrieve ${providerName} user info`, "USER_INFO_FAILED");
+    }
+  }
+  /**
+   * 프로바이더 어댑터 조회
+   */
+  getProvider(name) {
+    const provider = this.providers.get(name);
+    if (!provider) {
+      throw new OAuthError(`Unsupported OAuth provider: ${name}`, "UNSUPPORTED_PROVIDER");
+    }
+    return provider;
+  }
+  /**
+   * 프로바이더 설정 조회
+   */
+  getProviderConfig(providerName) {
+    const config = this.config.providers[providerName];
+    if (!config) {
+      throw new OAuthError(`${providerName} OAuth not configured`, `${providerName.toUpperCase()}_NOT_CONFIGURED`);
+    }
+    return config;
+  }
+};
+
+export {
+  OAuthManager
+};

package/dist/{chunk-N4D6OPPP.js → chunk-LLVIA4JX.js}

@@ -18,6 +18,7 @@ function getDefaultOptions() {
   };
 }
 function setTokenCookies(response, tokenPair, options = {}) {
+  var _a;
   const opts = __spreadValues(__spreadValues({}, getDefaultOptions()), options);
   response.cookies.set("access_token", tokenPair.accessToken, {
     httpOnly: true,
@@ -30,12 +31,13 @@ function setTokenCookies(response, tokenPair, options = {}) {
     httpOnly: true,
     secure: opts.secure,
     sameSite: opts.sameSite,
-    path: "/api/auth",
+    path: (_a = opts.refreshTokenPath) != null ? _a : "/api/auth",
     maxAge: 7 * 24 * 60 * 60
   });
   return response;
 }
 function clearTokenCookies(response, options = {}) {
+  var _a;
   const opts = __spreadValues(__spreadValues({}, getDefaultOptions()), options);
   response.cookies.set("access_token", "", {
     httpOnly: true,
@@ -48,7 +50,7 @@ function clearTokenCookies(response, options = {}) {
     httpOnly: true,
     secure: opts.secure,
     sameSite: opts.sameSite,
-    path: "/api/auth",
+    path: (_a = opts.refreshTokenPath) != null ? _a : "/api/auth",
     maxAge: 0
   });
   return response;

package/dist/{chunk-5WP57PJK.js → chunk-O3UR234Y.js}

@@ -1,3 +1,6 @@
+import {
+  initRequestMiddleware
+} from "./chunk-62Q7DN5G.js";
 import {
   MiddlewareChain
 } from "./chunk-FPESPW6P.js";
@@ -14,16 +17,13 @@ import {
   adminMiddleware,
   authMiddleware,
   optionalAuthMiddleware
-} from "./chunk-J5AISIJS.js";
+} from "./chunk-ZBXSEQ6W.js";
 import {
   corsMiddleware
 } from "./chunk-KGHWGLED.js";
 import {
   errorHandlerMiddleware
 } from "./chunk-3YUKCYHI.js";
-import {
-  initRequestMiddleware
-} from "./chunk-62Q7DN5G.js";
 
 // src/middleware/wrappers.ts
 function withPublicApi(handler) {

package/dist/{chunk-6D3HHYER.js → chunk-QKC73SWB.js}

@@ -1,14 +1,9 @@
 // src/auth/types/index.ts
-var UserRole = /* @__PURE__ */ ((UserRole2) => {
-  UserRole2["USER"] = "USER";
-  UserRole2["ADMIN"] = "ADMIN";
-  return UserRole2;
-})(UserRole || {});
-var OAuthProvider = /* @__PURE__ */ ((OAuthProvider2) => {
-  OAuthProvider2["GOOGLE"] = "google";
-  OAuthProvider2["GITHUB"] = "github";
-  return OAuthProvider2;
-})(OAuthProvider || {});
+var OAUTH_PROVIDERS = {
+  GOOGLE: "google",
+  GITHUB: "github",
+  KAKAO: "kakao"
+};
 var PasswordStrength = /* @__PURE__ */ ((PasswordStrength2) => {
   PasswordStrength2["VERY_WEAK"] = "VERY_WEAK";
   PasswordStrength2["WEAK"] = "WEAK";
@@ -25,8 +20,7 @@ var TokenType = /* @__PURE__ */ ((TokenType2) => {
 })(TokenType || {});
 
 export {
-  UserRole,
-  OAuthProvider,
+  OAUTH_PROVIDERS,
   PasswordStrength,
   TokenType
 };

package/dist/chunk-RVL5ROWQ.js

@@ -0,0 +1,62 @@
+import {
+  OAuthError
+} from "./chunk-AIH3F7JV.js";
+
+// src/auth/core/oauth/providers/google.ts
+var GoogleOAuthProvider = class {
+  constructor() {
+    this.name = "google";
+  }
+  getLoginUrl(config, state) {
+    const params = new URLSearchParams({
+      client_id: config.clientId,
+      redirect_uri: config.redirectUri,
+      response_type: "code",
+      scope: "openid email profile",
+      access_type: "offline",
+      prompt: "select_account consent"
+    });
+    if (state) {
+      params.set("state", state);
+    }
+    return `https://accounts.google.com/o/oauth2/v2/auth?${params.toString()}`;
+  }
+  async exchangeCodeForToken(config, code) {
+    const response = await fetch("https://oauth2.googleapis.com/token", {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: new URLSearchParams({
+        client_id: config.clientId,
+        client_secret: config.clientSecret,
+        code,
+        grant_type: "authorization_code",
+        redirect_uri: config.redirectUri
+      })
+    });
+    if (!response.ok) {
+      const errorData = await response.text();
+      throw new OAuthError(`Google token exchange failed: ${errorData}`, "TOKEN_EXCHANGE_FAILED");
+    }
+    return response.json();
+  }
+  async getUserInfo(accessToken) {
+    const response = await fetch("https://www.googleapis.com/oauth2/v2/userinfo", {
+      headers: { Authorization: `Bearer ${accessToken}` }
+    });
+    if (!response.ok) {
+      throw new OAuthError("Failed to get Google user info", "USER_INFO_FAILED");
+    }
+    const data = await response.json();
+    return {
+      id: data.id,
+      email: data.email,
+      name: data.name || null,
+      image: data.picture || null,
+      emailVerified: data.verified_email || false
+    };
+  }
+};
+
+export {
+  GoogleOAuthProvider
+};

package/dist/{chunk-J5AISIJS.js → chunk-ZBXSEQ6W.js}

@@ -72,7 +72,7 @@ function initializeAuthMiddleware() {
   return jwtManager !== null;
 }
 var authMiddleware = async (context, next) => {
-  var _a, _b, _c, _d;
+  var _a, _b, _c, _d, _e;
   try {
     const jwtManager = getJWTManager();
     if (!jwtManager) {
@@ -111,13 +111,13 @@ var authMiddleware = async (context, next) => {
       email: (_c = payload.email) != null ? _c : "",
       name: void 0,
       // 필요시 DB에서 조회
-      role: payload.role === "ADMIN" ? "ADMIN" : "USER"
+      role: (_d = payload.role) != null ? _d : "USER"
     };
   } catch (error) {
     if (error instanceof AppError) {
       throw error;
     }
-    if (error.code === "TOKEN_EXPIRED" || ((_d = error.message) == null ? void 0 : _d.includes("expired"))) {
+    if (error.code === "TOKEN_EXPIRED" || ((_e = error.message) == null ? void 0 : _e.includes("expired"))) {
       throw new AppError(ERROR_CODES.TOKEN_EXPIRED.code, error.message);
     }
     throw new AppError(
@@ -128,7 +128,7 @@ var authMiddleware = async (context, next) => {
   return await next();
 };
 var optionalAuthMiddleware = async (context, next) => {
-  var _a, _b, _c;
+  var _a, _b, _c, _d;
   try {
     const jwtManager = getJWTManager();
     if (jwtManager) {
@@ -149,7 +149,7 @@ var optionalAuthMiddleware = async (context, next) => {
             id: payload.userId,
             email: (_c = payload.email) != null ? _c : "",
             name: void 0,
-            role: payload.role === "ADMIN" ? "ADMIN" : "USER"
+            role: (_d = payload.role) != null ? _d : "USER"
           };
         }
       }
@@ -158,20 +158,24 @@ var optionalAuthMiddleware = async (context, next) => {
   }
   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();
-};
+function createRoleMiddleware(...allowedRoles) {
+  return async (context, next) => {
+    if (!context.user) {
+      throw new AppError(ERROR_CODES.UNAUTHORIZED.code);
+    }
+    if (!allowedRoles.includes(context.user.role)) {
+      throw new AppError(ERROR_CODES.FORBIDDEN.code);
+    }
+    return await next();
+  };
+}
+var adminMiddleware = createRoleMiddleware("ADMIN");
 
 export {
   setAccessTokenBlacklistChecker,
   initializeAuthMiddleware,
   authMiddleware,
   optionalAuthMiddleware,
+  createRoleMiddleware,
   adminMiddleware
 };

package/dist/config/registry.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Unified Config Registry
+ *
+ * Single entry point for all withwiz configuration.
+ * Stores resolved configs in globalThis.__withwiz_config and exposes
+ * them via a read-only Proxy (`config`).
+ */
+import type { ResolvedCommonConfig } from './common';
+import type { ResolvedAuthConfig } from '../auth/config';
+import type { ResolvedLoggerConfig } from '../logger/config';
+import type { ResolvedCacheConfig } from '../cache/config';
+import type { ResolvedStorageConfig } from '../storage/config';
+import type { ResolvedGeolocationConfig } from '../geolocation/config';
+import type { ResolvedCorsConfig } from '../middleware/cors-config';
+export interface ConfigRegistry {
+    common: ResolvedCommonConfig;
+    auth: ResolvedAuthConfig;
+    logger: ResolvedLoggerConfig;
+    cache?: ResolvedCacheConfig;
+    storage?: ResolvedStorageConfig;
+    geolocation?: ResolvedGeolocationConfig;
+    cors?: ResolvedCorsConfig;
+}
+declare global {
+    var __withwiz_config: ConfigRegistry | undefined;
+}
+/**
+ * Initialise the unified config registry.
+ * Idempotent — a second call is silently ignored.
+ * The stored object is frozen to prevent mutation.
+ */
+export declare function initConfig(entries: ConfigRegistry): void;
+/**
+ * Read-only Proxy that delegates to `globalThis.__withwiz_config`.
+ * Throws `ConfigurationError` if accessed before `initConfig()`.
+ * Throws `TypeError` on any setter attempt.
+ */
+export declare const config: ConfigRegistry;
+/**
+ * Reset the registry to uninitialised state. For test cleanup only.
+ */
+export declare function resetConfig(): void;

package/dist/config/registry.js

@@ -0,0 +1,12 @@
+import {
+  config,
+  initConfig,
+  resetConfig
+} from "../chunk-6PGZTY4N.js";
+import "../chunk-2QH66EVQ.js";
+import "../chunk-ORMEWXMH.js";
+export {
+  config,
+  initConfig,
+  resetConfig
+};