@thinkingcat/auth-utils 1.0.12 → 1.0.14

package/README.md

@@ -139,7 +139,7 @@ import {
   createMiddlewareConfig,
   handleMiddleware,
   verifyAndRefreshTokenWithNextAuth,
-  
+
   // 라이센스
   checkLicenseKey,
 
@@ -166,7 +166,8 @@ const response = await handleMiddleware(req, middlewareConfig, {
 });
 ```
 
-**중요**: 
+**중요**:
+
 - 라이센스 키는 모든 함수 호출 시 필수 파라미터입니다.
 - 라이센스 키가 없거나 유효하지 않으면 함수가 에러를 발생시킵니다.
 - 라이센스 키는 SHA-256 해시로 변환되어 모듈 내부의 유효한 키 목록과 비교됩니다.

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 import { JWT } from "next-auth/jwt";
+import type { Session } from "next-auth";
 import { NextResponse, NextRequest } from 'next/server';
 export interface ResponseLike {
     cookies: {
@@ -325,7 +326,141 @@ export interface MiddlewareOptions {
     /** 라이센스 키 (필수) */
     licenseKey: string;
 }
-export declare function checkLicenseKey(licenseKey: string): void;
+/**
+ * NextAuth 쿠키 설정 생성
+ * @param options 옵션
+ * @param options.isProduction 프로덕션 환경 여부
+ * @param options.cookieDomain 쿠키 도메인 (선택)
+ * @returns NextAuth 쿠키 설정 객체
+ */
+export declare function createNextAuthCookies(options: {
+    isProduction?: boolean;
+    cookieDomain?: string;
+}): {
+    sessionToken: {
+        name: string;
+        options: {
+            httpOnly: boolean;
+            sameSite: 'lax' | 'none';
+            path: string;
+            secure: boolean;
+            domain?: string;
+        };
+    };
+    callbackUrl: {
+        name: string;
+        options: {
+            sameSite: 'lax' | 'none';
+            path: string;
+            secure: boolean;
+            domain?: string;
+        };
+    };
+    csrfToken: {
+        name: string;
+        options: {
+            httpOnly: boolean;
+            sameSite: 'lax' | 'none';
+            path: string;
+            secure: boolean;
+            domain?: string;
+        };
+    };
+};
+/**
+ * NextAuth 기본 설정 생성
+ * @param options 옵션
+ * @param options.secret NextAuth secret
+ * @param options.isProduction 프로덕션 환경 여부
+ * @param options.cookieDomain 쿠키 도메인 (선택)
+ * @param options.signInPath 로그인 페이지 경로 (기본값: '/login')
+ * @param options.errorPath 에러 페이지 경로 (기본값: '/login')
+ * @param options.nextAuthUrl NextAuth URL (선택)
+ * @param options.sessionMaxAge 세션 최대 유지 시간 (초, 기본값: 30일)
+ * @param options.jwtMaxAge JWT 최대 유지 시간 (초, 기본값: 30일)
+ * @returns NextAuth 기본 설정 객체
+ */
+export declare function createNextAuthBaseConfig(options: {
+    secret: string;
+    isProduction?: boolean;
+    cookieDomain?: string;
+    signInPath?: string;
+    errorPath?: string;
+    nextAuthUrl?: string;
+    sessionMaxAge?: number;
+    jwtMaxAge?: number;
+}): {
+    session: {
+        strategy: 'jwt';
+        maxAge: number;
+    };
+    jwt: {
+        maxAge: number;
+    };
+    providers: never[];
+    url?: string;
+    pages: {
+        signIn: string;
+        error: string;
+    };
+    cookies: ReturnType<typeof createNextAuthCookies>;
+    secret: string;
+};
+/**
+ * JWT 콜백에서 초기 로그인 시 토큰 생성 헬퍼
+ * @param token 기존 토큰
+ * @param user 사용자 정보
+ * @param account 계정 정보
+ * @returns 업데이트된 JWT 토큰
+ */
+export declare function createInitialJWTToken(token: JWT, user: {
+    id: string;
+    email?: string | null;
+    emailHash?: string | null;
+    maskedEmail?: string | null;
+    phoneHash?: string | null;
+    maskedPhone?: string | null;
+    role?: string;
+    phone?: string | null;
+    decryptedEmail?: string | null;
+    decryptedPhone?: string | null;
+    refreshToken?: string | null;
+}, account?: {
+    serviceId?: string;
+} | null): JWT;
+/**
+ * Session 콜백에서 빈 세션 반환 헬퍼
+ * @param session 기존 세션
+ * @returns 빈 세션 객체
+ */
+export declare function createEmptySession(session: Session): Session;
+/**
+ * Session 콜백에서 토큰 정보를 세션에 매핑하는 헬퍼
+ * @param session 기존 세션
+ * @param token JWT 토큰
+ * @param options 옵션
+ * @param options.primaryAcademy 기본 학원 정보 (선택)
+ * @returns 업데이트된 세션
+ */
+export declare function mapTokenToSession(session: Session, token: JWT, options?: {
+    primaryAcademy?: {
+        id: string;
+        name: string;
+        role: string;
+    } | null;
+}): Session;
+/**
+ * 쿠키에서 커스텀 토큰을 읽어서 NextAuth JWT로 변환하는 헬퍼 함수
+ * NextAuth JWT 콜백에서 사용
+ * @param cookieName 쿠키 이름 (예: 'checkon_access_token')
+ * @param secret JWT 서명에 사용할 secret key
+ * @param serviceId 서비스 ID (필수)
+ * @param licenseKey 라이센스 키 (필수)
+ * @param includeAcademies academies 정보 포함 여부 (기본값: false)
+ * @returns NextAuth JWT 객체 또는 null
+ */
+export declare function getJWTFromCustomTokenCookie(cookieName: string, secret: string, serviceId: string, licenseKey: string, includeAcademies?: boolean): Promise<JWT | null>;
+export declare function checkLicenseKey(licenseKey: string): Promise<void>;
 export declare function checkRoleAccess(pathname: string, role: string, roleConfig: RoleAccessConfig): {
     allowed: boolean;
     message?: string;

package/dist/index.js

@@ -49,6 +49,12 @@ exports.redirectToError = redirectToError;
 exports.clearAuthCookies = clearAuthCookies;
 exports.getEffectiveRole = getEffectiveRole;
 exports.requiresSubscription = requiresSubscription;
+exports.createNextAuthCookies = createNextAuthCookies;
+exports.createNextAuthBaseConfig = createNextAuthBaseConfig;
+exports.createInitialJWTToken = createInitialJWTToken;
+exports.createEmptySession = createEmptySession;
+exports.mapTokenToSession = mapTokenToSession;
+exports.getJWTFromCustomTokenCookie = getJWTFromCustomTokenCookie;
 exports.checkLicenseKey = checkLicenseKey;
 exports.checkRoleAccess = checkRoleAccess;
 exports.redirectToSSOLogin = redirectToSSOLogin;
@@ -67,7 +73,14 @@ exports.handleMiddleware = handleMiddleware;
 const jwt_1 = require("next-auth/jwt");
 const jose_1 = require("jose");
 const server_1 = require("next/server");
-const crypto_1 = require("crypto");
+// Edge Runtime 호환을 위해 Web Crypto API 사용
+async function createHashSHA256(data) {
+    const encoder = new TextEncoder();
+    const dataBuffer = encoder.encode(data);
+    const hashBuffer = await crypto.subtle.digest('SHA-256', dataBuffer);
+    const hashArray = Array.from(new Uint8Array(hashBuffer));
+    return hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
+}
 /**
  * 토큰 검증 및 디코딩
  * @param accessToken JWT access token
@@ -331,7 +344,7 @@ function createRedirectHTML(redirectPath, text) {
  * @returns NextResponse 객체
  */
 async function createAuthResponse(accessToken, secret, options) {
-    checkLicenseKey(options.licenseKey);
+    await checkLicenseKey(options.licenseKey);
     const { refreshToken, redirectPath, text, cookiePrefix, isProduction = false, cookieDomain, serviceId, } = options;
     // 1. 토큰 검증
     const tokenResult = await verifyToken(accessToken, secret);
@@ -600,11 +613,197 @@ function requiresSubscription(pathname, role, subscriptionRequiredPaths, systemA
 const VALID_LICENSE_KEY_HASHES = new Set([
     '73bce4f3b64804c255cdab450d759a8b53038f9edb59ae42d9988b08dfd007e2',
 ]);
-function checkLicenseKey(licenseKey) {
+/**
+ * NextAuth 쿠키 설정 생성
+ * @param options 옵션
+ * @param options.isProduction 프로덕션 환경 여부
+ * @param options.cookieDomain 쿠키 도메인 (선택)
+ * @returns NextAuth 쿠키 설정 객체
+ */
+function createNextAuthCookies(options) {
+    const { isProduction = false, cookieDomain } = options;
+    const isSecure = isProduction;
+    return {
+        sessionToken: {
+            name: isSecure ? `__Secure-next-auth.session-token` : `next-auth.session-token`,
+            options: {
+                httpOnly: true,
+                sameSite: isSecure ? 'none' : 'lax',
+                path: '/',
+                secure: isSecure,
+                ...(cookieDomain && { domain: cookieDomain }),
+            },
+        },
+        callbackUrl: {
+            name: isSecure ? `__Secure-next-auth.callback-url` : `next-auth.callback-url`,
+            options: {
+                sameSite: isSecure ? 'none' : 'lax',
+                path: '/',
+                secure: isSecure,
+                ...(cookieDomain && { domain: cookieDomain }),
+            },
+        },
+        csrfToken: {
+            name: isSecure ? `__Secure-next-auth.csrf-token` : `next-auth.csrf-token`,
+            options: {
+                httpOnly: true,
+                sameSite: isSecure ? 'none' : 'lax',
+                path: '/',
+                secure: isSecure,
+                ...(cookieDomain && { domain: cookieDomain }),
+            },
+        },
+    };
+}
+/**
+ * NextAuth 기본 설정 생성
+ * @param options 옵션
+ * @param options.secret NextAuth secret
+ * @param options.isProduction 프로덕션 환경 여부
+ * @param options.cookieDomain 쿠키 도메인 (선택)
+ * @param options.signInPath 로그인 페이지 경로 (기본값: '/login')
+ * @param options.errorPath 에러 페이지 경로 (기본값: '/login')
+ * @param options.nextAuthUrl NextAuth URL (선택)
+ * @param options.sessionMaxAge 세션 최대 유지 시간 (초, 기본값: 30일)
+ * @param options.jwtMaxAge JWT 최대 유지 시간 (초, 기본값: 30일)
+ * @returns NextAuth 기본 설정 객체
+ */
+function createNextAuthBaseConfig(options) {
+    const { secret, isProduction = false, cookieDomain, signInPath = '/login', errorPath = '/login', nextAuthUrl, sessionMaxAge = 30 * 24 * 60 * 60, // 30일
+    jwtMaxAge = 30 * 24 * 60 * 60, // 30일
+     } = options;
+    return {
+        session: {
+            strategy: 'jwt',
+            maxAge: sessionMaxAge,
+        },
+        jwt: {
+            maxAge: jwtMaxAge,
+        },
+        providers: [],
+        ...(nextAuthUrl && { url: nextAuthUrl }),
+        pages: {
+            signIn: signInPath,
+            error: errorPath,
+        },
+        cookies: createNextAuthCookies({ isProduction, cookieDomain }),
+        secret,
+    };
+}
+/**
+ * JWT 콜백에서 초기 로그인 시 토큰 생성 헬퍼
+ * @param token 기존 토큰
+ * @param user 사용자 정보
+ * @param account 계정 정보
+ * @returns 업데이트된 JWT 토큰
+ */
+function createInitialJWTToken(token, user, account) {
+    return {
+        ...token,
+        id: user.id,
+        email: user.email ?? undefined,
+        emailHash: user.emailHash ?? undefined,
+        maskedEmail: user.maskedEmail ?? undefined,
+        phoneHash: user.phoneHash ?? undefined,
+        maskedPhone: user.maskedPhone ?? undefined,
+        role: user.role,
+        phone: user.phone ?? undefined,
+        decryptedEmail: user.decryptedEmail ?? undefined,
+        decryptedPhone: user.decryptedPhone ?? undefined,
+        refreshToken: user.refreshToken ?? undefined,
+        accessTokenExpires: Date.now() + (15 * 60 * 1000), // 15분
+        serviceId: account?.serviceId ?? undefined,
+    };
+}
+/**
+ * Session 콜백에서 빈 세션 반환 헬퍼
+ * @param session 기존 세션
+ * @returns 빈 세션 객체
+ */
+function createEmptySession(session) {
+    return {
+        ...session,
+        user: {
+            ...session.user,
+            id: '',
+            email: null,
+            role: 'GUEST',
+        },
+        expires: new Date().toISOString(),
+    };
+}
+/**
+ * Session 콜백에서 토큰 정보를 세션에 매핑하는 헬퍼
+ * @param session 기존 세션
+ * @param token JWT 토큰
+ * @param options 옵션
+ * @param options.primaryAcademy 기본 학원 정보 (선택)
+ * @returns 업데이트된 세션
+ */
+function mapTokenToSession(session, token, options) {
+    if (!session.user) {
+        return session;
+    }
+    const { primaryAcademy } = options || {};
+    const user = session.user;
+    user.id = token.id;
+    user.email = token.email;
+    user.name = token.name;
+    user.role = primaryAcademy?.role || token.role;
+    user.academyId = primaryAcademy?.id;
+    user.academyName = primaryAcademy?.name;
+    if (token.academies && Array.isArray(token.academies)) {
+        user.academies = token.academies.map((ua) => ({
+            id: ua.id,
+            name: ua.name,
+        }));
+    }
+    user.smsVerified = token.smsVerified;
+    user.emailVerified = token.emailVerified;
+    user.phone = token.phone;
+    user.phoneVerified = token.phoneVerified;
+    user.isPasswordReset = token.isPasswordReset || false;
+    user.decryptedEmail = token.decryptedEmail;
+    user.decryptedPhone = token.decryptedPhone;
+    return session;
+}
+/**
+ * 쿠키에서 커스텀 토큰을 읽어서 NextAuth JWT로 변환하는 헬퍼 함수
+ * NextAuth JWT 콜백에서 사용
+ * @param cookieName 쿠키 이름 (예: 'checkon_access_token')
+ * @param secret JWT 서명에 사용할 secret key
+ * @param serviceId 서비스 ID (필수)
+ * @param licenseKey 라이센스 키 (필수)
+ * @param includeAcademies academies 정보 포함 여부 (기본값: false)
+ * @returns NextAuth JWT 객체 또는 null
+ */
+async function getJWTFromCustomTokenCookie(cookieName, secret, serviceId, licenseKey, includeAcademies = false) {
+    try {
+        const { cookies } = await Promise.resolve().then(() => __importStar(require('next/headers')));
+        const cookieStore = await cookies();
+        const accessToken = cookieStore.get(cookieName)?.value;
+        if (!accessToken) {
+            return null;
+        }
+        await checkLicenseKey(licenseKey);
+        const tokenResult = await verifyToken(accessToken, secret);
+        if (!tokenResult) {
+            return null;
+        }
+        const { payload } = tokenResult;
+        const jwt = createNextAuthJWT(payload, serviceId, includeAcademies);
+        return jwt;
+    }
+    catch (error) {
+        console.error(`[getJWTFromCustomTokenCookie] Failed to read ${cookieName}:`, error);
+        return null;
+    }
+}
+async function checkLicenseKey(licenseKey) {
     if (!licenseKey || licenseKey.length < 10) {
         throw new Error('License key is required');
     }
-    const keyHash = (0, crypto_1.createHash)('sha256').update(licenseKey).digest('hex');
+    const keyHash = await createHashSHA256(licenseKey);
     if (!VALID_LICENSE_KEY_HASHES.has(keyHash)) {
         throw new Error('Invalid license key');
     }
@@ -858,7 +1057,7 @@ async function handleMiddleware(req, config, options) {
     try {
         const pathname = req.nextUrl.pathname;
         const { secret, isProduction, cookieDomain, getNextAuthToken, licenseKey } = options;
-        checkLicenseKey(licenseKey);
+        await checkLicenseKey(licenseKey);
         if (!config.serviceId) {
             throw new Error('serviceId is required in middleware config');
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thinkingcat/auth-utils",
-  "version": "1.0.12",
+  "version": "1.0.14",
   "description": "Authentication utilities for ThinkingCat SSO services",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",