@withwiz/toolkit 0.1.0

package/dist/chunk-V5K5FYU7.js

@@ -0,0 +1,200 @@
+import {
+  OAuthError
+} from "./chunk-AIH3F7JV.js";
+
+// src/auth/core/oauth/index.ts
+var OAuthManager = class {
+  constructor(config, logger) {
+    this.config = config;
+    this.logger = logger;
+  }
+  /**
+   * OAuth 로그인 URL 생성
+   */
+  getLoginUrl(provider, state) {
+    if (provider === "google" /* GOOGLE */) {
+      return this.getGoogleLoginUrl(state);
+    } else if (provider === "github" /* GITHUB */) {
+      return this.getGitHubLoginUrl(state);
+    }
+    throw new OAuthError(`Unsupported OAuth provider: ${provider}`, "UNSUPPORTED_PROVIDER");
+  }
+  /**
+   * Google OAuth 로그인 URL
+   */
+  getGoogleLoginUrl(state) {
+    if (!this.config.google) {
+      throw new OAuthError("Google OAuth not configured", "GOOGLE_NOT_CONFIGURED");
+    }
+    const params = new URLSearchParams({
+      client_id: this.config.google.clientId,
+      redirect_uri: this.config.google.redirectUri,
+      response_type: "code",
+      scope: "openid email profile",
+      state,
+      access_type: "offline",
+      prompt: "select_account consent"
+    });
+    return `https://accounts.google.com/o/oauth2/v2/auth?${params.toString()}`;
+  }
+  /**
+   * GitHub OAuth 로그인 URL
+   */
+  getGitHubLoginUrl(state) {
+    if (!this.config.github) {
+      throw new OAuthError("GitHub OAuth not configured", "GITHUB_NOT_CONFIGURED");
+    }
+    const params = new URLSearchParams({
+      client_id: this.config.github.clientId,
+      redirect_uri: this.config.github.redirectUri,
+      scope: "read:user user:email",
+      state
+    });
+    return `https://github.com/login/oauth/authorize?${params.toString()}`;
+  }
+  /**
+   * 인증 코드를 액세스 토큰으로 교환
+   */
+  async exchangeCodeForToken(provider, code) {
+    if (provider === "google" /* GOOGLE */) {
+      return this.exchangeGoogleCode(code);
+    } else if (provider === "github" /* GITHUB */) {
+      return this.exchangeGitHubCode(code);
+    }
+    throw new OAuthError(`Unsupported OAuth provider: ${provider}`, "UNSUPPORTED_PROVIDER");
+  }
+  /**
+   * Google 코드 교환
+   */
+  async exchangeGoogleCode(code) {
+    if (!this.config.google) {
+      throw new OAuthError("Google OAuth not configured", "GOOGLE_NOT_CONFIGURED");
+    }
+    try {
+      const response = await fetch("https://oauth2.googleapis.com/token", {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: new URLSearchParams({
+          client_id: this.config.google.clientId,
+          client_secret: this.config.google.clientSecret,
+          code,
+          grant_type: "authorization_code",
+          redirect_uri: this.config.google.redirectUri
+        })
+      });
+      if (!response.ok) {
+        const errorData = await response.text();
+        this.logger.error("Google token exchange failed", { status: response.status, errorData });
+        throw new OAuthError("Failed to exchange Google code for token", "TOKEN_EXCHANGE_FAILED");
+      }
+      const data = await response.json();
+      this.logger.debug("Google token exchange successful");
+      return data.access_token;
+    } catch (error) {
+      this.logger.error("Google token exchange error", { error: error.message });
+      throw new OAuthError("Google token exchange failed", "TOKEN_EXCHANGE_FAILED");
+    }
+  }
+  /**
+   * GitHub 코드 교환
+   */
+  async exchangeGitHubCode(code) {
+    if (!this.config.github) {
+      throw new OAuthError("GitHub OAuth not configured", "GITHUB_NOT_CONFIGURED");
+    }
+    try {
+      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: this.config.github.clientId,
+          client_secret: this.config.github.clientSecret,
+          code,
+          redirect_uri: this.config.github.redirectUri
+        })
+      });
+      if (!response.ok) {
+        const errorData = await response.text();
+        this.logger.error("GitHub token exchange failed", { status: response.status, errorData });
+        throw new OAuthError("Failed to exchange GitHub code for token", "TOKEN_EXCHANGE_FAILED");
+      }
+      const data = await response.json();
+      this.logger.debug("GitHub token exchange successful");
+      return data.access_token;
+    } catch (error) {
+      this.logger.error("GitHub token exchange error", { error: error.message });
+      throw new OAuthError("GitHub token exchange failed", "TOKEN_EXCHANGE_FAILED");
+    }
+  }
+  /**
+   * 사용자 정보 가져오기
+   */
+  async getUserInfo(provider, accessToken) {
+    if (provider === "google" /* GOOGLE */) {
+      return this.getGoogleUserInfo(accessToken);
+    } else if (provider === "github" /* GITHUB */) {
+      return this.getGitHubUserInfo(accessToken);
+    }
+    throw new OAuthError(`Unsupported OAuth provider: ${provider}`, "UNSUPPORTED_PROVIDER");
+  }
+  /**
+   * Google 사용자 정보
+   */
+  async getGoogleUserInfo(accessToken) {
+    try {
+      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();
+      this.logger.debug("Google user info retrieved", { userId: data.id, email: data.email });
+      return {
+        id: data.id,
+        email: data.email,
+        name: data.name || null,
+        image: data.picture || null,
+        emailVerified: data.verified_email || false
+      };
+    } catch (error) {
+      this.logger.error("Google user info error", { error: error.message });
+      throw new OAuthError("Failed to retrieve Google user info", "USER_INFO_FAILED");
+    }
+  }
+  /**
+   * GitHub 사용자 정보
+   */
+  async getGitHubUserInfo(accessToken) {
+    try {
+      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();
+      this.logger.debug("GitHub user info retrieved", { userId: data.id, login: data.login });
+      return {
+        id: data.id.toString(),
+        email: data.email,
+        name: data.name || null,
+        image: data.avatar_url || null,
+        emailVerified: !!data.email
+      };
+    } catch (error) {
+      this.logger.error("GitHub user info error", { error: error.message });
+      throw new OAuthError("Failed to retrieve GitHub user info", "USER_INFO_FAILED");
+    }
+  }
+};
+
+export {
+  OAuthManager
+};

package/dist/chunk-VDXB5DCY.js

@@ -0,0 +1,68 @@
+// src/constants/pagination.ts
+var PAGINATION = {
+  // 기본 페이지 크기
+  DEFAULT_PAGE_SIZE: 10,
+  // 최대 페이지 크기
+  MAX_PAGE_SIZE: 100,
+  // 최소 페이지 크기
+  MIN_PAGE_SIZE: 1,
+  // 기본 시작 페이지
+  DEFAULT_PAGE: 1
+};
+var PAGE_SIZES = {
+  // 링크 목록
+  LINKS: 10,
+  // 사용자 목록
+  USERS: 20,
+  // 예약어 목록
+  RESERVED_WORDS: 20,
+  // 공지사항 목록
+  NOTICES: 10,
+  // 태그 목록
+  TAGS: 50,
+  // 클릭 히스토리
+  CLICK_HISTORY: 50,
+  // 활동 내역
+  ACTIVITY: 20,
+  // 검색 결과
+  SEARCH_RESULTS: 10
+};
+var SORT_OPTIONS = {
+  // 기본 정렬 필드
+  DEFAULT_FIELD: "createdAt",
+  // 기본 정렬 방향
+  DEFAULT_ORDER: "desc",
+  // 허용되는 정렬 방향
+  ALLOWED_ORDERS: ["asc", "desc"]
+};
+var FILTER_OPTIONS = {
+  // 기본 필터
+  DEFAULT: "all",
+  // 활성 상태 필터
+  ACTIVE_FILTER: {
+    ALL: "all",
+    ACTIVE: "active",
+    INACTIVE: "inactive"
+  },
+  // 공개 상태 필터
+  PUBLIC_FILTER: {
+    ALL: "all",
+    PUBLIC: "public",
+    PRIVATE: "private"
+  }
+};
+var DATE_RANGE = {
+  // 최근 N일
+  LAST_7_DAYS: 7,
+  LAST_30_DAYS: 30,
+  LAST_90_DAYS: 90,
+  LAST_365_DAYS: 365
+};
+
+export {
+  PAGINATION,
+  PAGE_SIZES,
+  SORT_OPTIONS,
+  FILTER_OPTIONS,
+  DATE_RANGE
+};

package/dist/chunk-VSGKVZB4.js

@@ -0,0 +1,47 @@
+import {
+  BaseGeoIPProvider,
+  truncateString
+} from "./chunk-AHDPGRXS.js";
+
+// src/geolocation/providers/ipapi-co-provider.ts
+var IPApiCoProvider = class extends BaseGeoIPProvider {
+  constructor() {
+    super(...arguments);
+    this.name = "ipapi.co";
+    this.rateLimit = 1e3;
+    // 분당 1000회 요청 제한
+    this.timeout = 5e3;
+  }
+  // 5초 타임아웃
+  url(ip) {
+    return `https://ipapi.co/${ip}/json/`;
+  }
+  parseResponse(data) {
+    if (data.country_code) {
+      return {
+        ipAddress: "",
+        // IP는 별도로 설정
+        country: truncateString(data.country_code, 2) || void 0,
+        countryName: truncateString(data.country_name, 100) || void 0,
+        region: truncateString(data.region, 100) || void 0,
+        regionCode: truncateString(data.region_code, 10) || void 0,
+        city: truncateString(data.city, 100) || void 0,
+        latitude: data.latitude,
+        longitude: data.longitude,
+        timezone: truncateString(data.timezone, 50) || void 0,
+        isp: truncateString(data.org, 500) || void 0,
+        organization: truncateString(data.org, 500) || void 0,
+        asn: truncateString(data.asn, 50) || void 0,
+        isPrivate: false,
+        isProxy: false,
+        accuracy: 1e3,
+        lastUpdated: /* @__PURE__ */ new Date()
+      };
+    }
+    return null;
+  }
+};
+
+export {
+  IPApiCoProvider
+};

package/dist/chunk-VWODEQ5C.js

@@ -0,0 +1,204 @@
+// src/utils/url-normalizer.ts
+var SUPPORTED_SCHEMES = [
+  "http:",
+  "https:",
+  "mailto:",
+  "tel:",
+  "sms:",
+  "ftp:",
+  "ftps:",
+  // 'file:' - 보안상 제거 (로컬 파일 접근 방지)
+  // 'data:' - XSS 공격 벡터로 제거 (CVSS 7.5)
+  // Mobile app schemes
+  "intent:",
+  "market:",
+  "itms:",
+  "itms-apps:",
+  // Social media apps
+  "fb:",
+  "instagram:",
+  "twitter:",
+  "youtube:",
+  "linkedin:",
+  "tiktok:",
+  // Messaging apps
+  "whatsapp:",
+  "telegram:",
+  "line:",
+  "kakaotalk:",
+  "viber:",
+  "wechat:",
+  "slack:",
+  "discord:",
+  // Other apps
+  "spotify:",
+  "zoom:",
+  "skype:",
+  "maps:",
+  "geo:"
+];
+var CUSTOM_SCHEME_PATTERN = /^[a-zA-Z][a-zA-Z0-9+.-]*:/;
+function hasValidScheme(url) {
+  try {
+    const urlObj = new URL(url);
+    const protocol = urlObj.protocol;
+    if (SUPPORTED_SCHEMES.includes(protocol)) {
+      return true;
+    }
+    if (CUSTOM_SCHEME_PATTERN.test(url)) {
+      return true;
+    }
+    return false;
+  } catch (e) {
+    return false;
+  }
+}
+function extractScheme(url) {
+  const match = url.match(/^([a-zA-Z][a-zA-Z0-9+.-]*):\/?\/?/);
+  return match ? match[1] : null;
+}
+function normalizeUrl(url) {
+  if (!url) {
+    return "";
+  }
+  let normalized = url.trim();
+  if (!normalized) {
+    return "";
+  }
+  const scheme = extractScheme(normalized);
+  if (scheme) {
+    return normalized;
+  }
+  if (normalized.startsWith("//")) {
+    return `https:${normalized}`;
+  }
+  return `https://${normalized}`;
+}
+function validateUrl(url, options) {
+  if (!url || !url.trim()) {
+    return {
+      isValid: false,
+      message: "URL\uC744 \uC785\uB825\uD574\uC8FC\uC138\uC694",
+      messageKey: "urlRequired"
+    };
+  }
+  const normalized = (options == null ? void 0 : options.skipNormalization) ? url.trim() : normalizeUrl(url);
+  try {
+    const urlObj = new URL(normalized);
+    const protocol = urlObj.protocol;
+    const isSupported = SUPPORTED_SCHEMES.includes(protocol);
+    const isCustom = CUSTOM_SCHEME_PATTERN.test(normalized);
+    if (!isSupported && !isCustom) {
+      return {
+        isValid: false,
+        message: `\uC9C0\uC6D0\uD558\uC9C0 \uC54A\uB294 \uD504\uB85C\uD1A0\uCF5C\uC785\uB2C8\uB2E4: ${protocol}`,
+        messageKey: "unsupportedProtocol",
+        messageParams: { protocol }
+      };
+    }
+    if (protocol === "http:" || protocol === "https:") {
+      if (!urlObj.hostname || urlObj.hostname.length < 1) {
+        return {
+          isValid: false,
+          message: "\uC720\uD6A8\uD55C \uB3C4\uBA54\uC778\uC744 \uC785\uB825\uD574\uC8FC\uC138\uC694",
+          messageKey: "invalidDomain"
+        };
+      }
+      if (!urlObj.hostname.includes(".") && urlObj.hostname !== "localhost") {
+        return {
+          isValid: false,
+          message: "\uC720\uD6A8\uD55C \uB3C4\uBA54\uC778 \uD615\uC2DD\uC774 \uC544\uB2D9\uB2C8\uB2E4",
+          messageKey: "invalidDomainFormat"
+        };
+      }
+    }
+    if (protocol === "mailto:") {
+      const email = urlObj.pathname;
+      const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+      if (!emailRegex.test(email)) {
+        return {
+          isValid: false,
+          message: "\uC720\uD6A8\uD55C \uC774\uBA54\uC77C \uC8FC\uC18C\uAC00 \uC544\uB2D9\uB2C8\uB2E4",
+          messageKey: "invalidEmail"
+        };
+      }
+    }
+    if (protocol === "tel:") {
+      const phone = urlObj.pathname;
+      if (!/\d/.test(phone)) {
+        return {
+          isValid: false,
+          message: "\uC720\uD6A8\uD55C \uC804\uD654\uBC88\uD638\uAC00 \uC544\uB2D9\uB2C8\uB2E4",
+          messageKey: "invalidPhone"
+        };
+      }
+    }
+    if (normalized.length > 2048) {
+      return {
+        isValid: false,
+        message: "URL\uC774 \uB108\uBB34 \uAE41\uB2C8\uB2E4 (\uCD5C\uB300 2048\uC790)",
+        messageKey: "urlTooLong"
+      };
+    }
+    return {
+      isValid: true,
+      message: "\uC720\uD6A8\uD55C URL\uC785\uB2C8\uB2E4",
+      messageKey: "validUrl",
+      normalizedUrl: normalized
+    };
+  } catch (error) {
+    return {
+      isValid: false,
+      message: "\uC720\uD6A8\uD55C URL \uD615\uC2DD\uC774 \uC544\uB2D9\uB2C8\uB2E4",
+      messageKey: "invalidUrlFormat"
+    };
+  }
+}
+function isWebUrl(url) {
+  try {
+    const urlObj = new URL(url);
+    return urlObj.protocol === "http:" || urlObj.protocol === "https:";
+  } catch (e) {
+    return false;
+  }
+}
+function isAppScheme(url) {
+  try {
+    const urlObj = new URL(url);
+    return !["http:", "https:", "ftp:", "ftps:", "file:"].includes(urlObj.protocol);
+  } catch (e) {
+    return false;
+  }
+}
+function getUrlType(url) {
+  try {
+    const urlObj = new URL(url);
+    const protocol = urlObj.protocol;
+    if (protocol === "http:" || protocol === "https:") {
+      return "web";
+    }
+    if (protocol === "mailto:") {
+      return "email";
+    }
+    if (protocol === "tel:" || protocol === "sms:") {
+      return "tel";
+    }
+    if (isAppScheme(url)) {
+      return "app";
+    }
+    return "other";
+  } catch (e) {
+    return "other";
+  }
+}
+
+export {
+  SUPPORTED_SCHEMES,
+  hasValidScheme,
+  extractScheme,
+  normalizeUrl,
+  validateUrl,
+  isWebUrl,
+  isAppScheme,
+  getUrlType
+};