// 개발 환경 또는 AUTH_UTILS_DEBUG=true일 때만 출력됨
[handleMiddleware] Processing: /admin
[verifyAndRefreshToken] Checking refresh: { hasRefreshToken: true, forceRefresh: false }
[createAuthResponse] JWT created: { hasId: true, hasEmail: true, hasRole: true }

/** @type {import('next').NextConfig} */
const nextConfig = {
  transpilePackages: ["@thinkingcat/auth-utils"],
  // ... 기타 설정
};

module.exports = nextConfig;

import {
  // 토큰 검증 및 생성
  verifyToken,
  extractRoleFromPayload,
  createNextAuthJWT,
  encodeNextAuthToken,

  // 쿠키 관리
  setCustomTokens,
  setNextAuthToken,
  clearAuthCookies,

  // 리다이렉트 및 응답
  createRedirectHTML,
  createAuthResponse,
  redirectToError,
  redirectToSSOLogin,
  redirectToRoleDashboard,

  // 역할 및 접근 제어
  getEffectiveRole,
  hasRole,
  hasAnyRole,
  checkRoleAccess,
  requiresSubscription,

  // 경로 체크
  isPublicPath,
  isApiPath,
  isProtectedApiPath,

  // 토큰 유효성 검사
  isTokenExpired,
  isValidToken,

  // SSO 통합
  refreshSSOToken,
  getRefreshTokenFromSSO,
  verifyTokenFromSSO,
  validateServiceSubscription,

  // 미들웨어
  createMiddlewareConfig,
  handleMiddleware,
  verifyAndRefreshTokenWithNextAuth,

  // NextAuth 설정 및 콜백
  createNextAuthBaseConfig,
  createNextAuthCookies,
  handleJWTCallback,
  createInitialJWTToken,
  createEmptySession,
  mapTokenToSession,
  getJWTFromCustomTokenCookie,

  // 라이센스
  checkLicenseKey,

  // 타입
  ServiceInfo,
  ResponseLike,
  JWTPayload,
  MiddlewareConfig,
  MiddlewareOptions,
} from "@thinkingcat/auth-utils";

// 예시: handleMiddleware 사용 시
const response = await handleMiddleware(req, middlewareConfig, {
  secret: process.env.NEXTAUTH_SECRET!,
  isProduction: process.env.NODE_ENV === "production",
  ssoBaseURL: process.env.SSO_BASE_URL!,
  licenseKey: process.env.LICENSE_KEY!, // 필수
});

const secret = process.env.NEXTAUTH_SECRET!;
const licenseKey = process.env.LICENSE_KEY!;
const result = await verifyToken(accessToken, secret, licenseKey);

if (result) {
  const { payload } = result;
  console.log("User email:", payload.email);
  console.log("User ID:", payload.sub || payload.id);
} else {
  console.log("Invalid token");
}

const role = extractRoleFromPayload(payload, "myservice", "ADMIN");
// 'ADMIN', 'TEACHER', 'STUDENT' 등

const jwt = createNextAuthJWT(payload, "myservice");

const secret = process.env.NEXTAUTH_SECRET!;
const jwt = createNextAuthJWT(payload, "myservice");
const sessionToken = await encodeNextAuthToken(jwt, secret);

// 방법 1: refreshToken이 있는 경우
setCustomTokens(response, accessToken, refreshToken, {
  cookiePrefix: "myservice",
  isProduction: process.env.NODE_ENV === "production",
});

// 방법 2: refreshToken이 없는 경우
setCustomTokens(response, accessToken, {
  cookiePrefix: "myservice",
  isProduction: process.env.NODE_ENV === "production",
});

setNextAuthToken(response, sessionToken, {
  isProduction: process.env.NODE_ENV === "production",
  cookieDomain: process.env.COOKIE_DOMAIN,
});

const response = NextResponse.redirect("/login");
clearAuthCookies(response, "myservice");
return response;

const result = await refreshSSOToken(refreshToken, {
  ssoBaseURL: process.env.SSO_BASE_URL!,
  authServiceKey: process.env.AUTH_SERVICE_SECRET_KEY,
});

import { createNextAuthBaseConfig } from "@thinkingcat/auth-utils";

const baseConfig = createNextAuthBaseConfig({
  secret: process.env.NEXTAUTH_SECRET!,
  isProduction: process.env.NODE_ENV === "production",
  cookieDomain: process.env.COOKIE_DOMAIN,
  signInPath: "/login",
  errorPath: "/login",
  nextAuthUrl: process.env.NEXTAUTH_URL,
});

export const authOptions: NextAuthOptions = {
  ...baseConfig,
  // ... 기타 설정
};

import { handleJWTCallback } from "@thinkingcat/auth-utils";

async jwt({ token, user, account }) {
  return handleJWTCallback(
    token,
    user ? {
      id: user.id,
      email: user.email,
      role: user.role,
      // ... 기타 사용자 정보
    } : null,
    account,
    {
      secret: process.env.NEXTAUTH_SECRET!,
      licenseKey: process.env.LICENSE_KEY!,
      serviceId: 'myservice',
      cookieName: 'myservice_access_token',
      debug: true,
    }
  );
}

import { createMiddlewareConfig } from "@thinkingcat/auth-utils";

const middlewareConfig = createMiddlewareConfig({
  serviceId: "myservice",
  publicPaths: ["/login", "/register"],
  roleAccessConfig: [
    {
      paths: ["/admin"],
      role: "ADMIN",
      message: "관리자만 접근할 수 있습니다.",
    },
  ],
});

import { withAuth } from "next-auth/middleware";
import { NextRequest, NextResponse } from "next/server";
import { getToken } from "next-auth/jwt";
import {
  createMiddlewareConfig,
  handleMiddleware,
} from "@thinkingcat/auth-utils";

const middlewareConfig = createMiddlewareConfig({
  serviceId: "myservice",
  publicPaths: ["/login", "/register"],
  roleAccessConfig: [
    {
      paths: ["/admin"],
      role: "ADMIN",
      message: "관리자만 접근할 수 있습니다.",
    },
  ],
});

export default withAuth(
  async function middleware(req: NextRequest) {
    const response = await handleMiddleware(req, middlewareConfig, {
      secret: process.env.NEXTAUTH_SECRET!,
      isProduction: process.env.NODE_ENV === "production",
      cookieDomain: process.env.COOKIE_DOMAIN,
      ssoBaseURL: process.env.SSO_BASE_URL!,
      getNextAuthToken: async (req: NextRequest) => {
        return await getToken({ req, secret: process.env.NEXTAUTH_SECRET! });
      },
      authServiceKey: process.env.AUTH_SERVICE_SECRET_KEY,
    });
    return response || NextResponse.next();
  },
  {
    callbacks: {
      authorized: () => true,
    },
  }
);

import { checkLicenseKey } from "@thinkingcat/auth-utils";

try {
  checkLicenseKey(process.env.LICENSE_KEY!);
  console.log("라이센스 키가 유효합니다");
} catch (error) {
  console.error("라이센스 키 검증 실패:", error);
}

const html = createRedirectHTML("/dashboard", "myservice");
return new NextResponse(html, {
  status: 200,
  headers: { "Content-Type": "text/html" },
});

const secret = process.env.NEXTAUTH_SECRET!;
const response = await createAuthResponse(accessToken, secret, {
  refreshToken: refreshToken,
  redirectPath: "/dashboard",
  text: "myservice",
  cookiePrefix: "myservice",
  isProduction: process.env.NODE_ENV === "production",
  cookieDomain: process.env.COOKIE_DOMAIN,
  serviceId: "myservice",
  licenseKey: process.env.LICENSE_KEY!, // 필수
});

import { NextRequest, NextResponse } from "next/server";
import {
  verifyToken,
  setCustomTokens,
  createRedirectHTML,
} from "@thinkingcat/auth-utils";

export async function GET(req: NextRequest) {
  const tokenParam = req.nextUrl.searchParams.get("token");
  if (!tokenParam) {
    return NextResponse.redirect("/login");
  }

  const secret = process.env.NEXTAUTH_SECRET!;
  const licenseKey = process.env.LICENSE_KEY!;
  const tokenResult = await verifyToken(tokenParam, secret, licenseKey);

  if (!tokenResult) {
    return NextResponse.redirect("/login");
  }

  const html = createRedirectHTML("/dashboard", "myservice");
  const response = new NextResponse(html, {
    status: 200,
    headers: { "Content-Type": "text/html" },
  });

  setCustomTokens(response, tokenParam, {
    cookiePrefix: "myservice",
    isProduction: process.env.NODE_ENV === "production",
  });

  return response;
}

import { NextRequest, NextResponse } from "next/server";
import {
  verifyToken,
  createNextAuthJWT,
  encodeNextAuthToken,
  setNextAuthToken,
} from "@thinkingcat/auth-utils";

export async function GET(req: NextRequest) {
  const tokenParam = req.nextUrl.searchParams.get("token");
  if (!tokenParam) {
    return NextResponse.redirect("/login");
  }

  const secret = process.env.NEXTAUTH_SECRET!;
  const licenseKey = process.env.LICENSE_KEY!;
  const tokenResult = await verifyToken(tokenParam, secret, licenseKey);

  if (!tokenResult) {
    return NextResponse.redirect("/login");
  }

  const { payload } = tokenResult;
  const jwt = createNextAuthJWT(payload, "myservice");
  const sessionToken = await encodeNextAuthToken(jwt, secret);

  const response = NextResponse.redirect("/dashboard");
  setNextAuthToken(response, sessionToken, {
    isProduction: process.env.NODE_ENV === "production",
    cookieDomain: process.env.COOKIE_DOMAIN,
  });

  return response;
}

import { NextRequest, NextResponse } from "next/server";
import {
  verifyToken,
  extractRoleFromPayload,
  createNextAuthJWT,
  encodeNextAuthToken,
  setCustomTokens,
  setNextAuthToken,
  createRedirectHTML,
} from "@thinkingcat/auth-utils";

export async function GET(req: NextRequest) {
  const tokenParam = req.nextUrl.searchParams.get("token");
  if (!tokenParam) {
    return NextResponse.redirect("/login");
  }

  const secret = process.env.NEXTAUTH_SECRET!;
  const licenseKey = process.env.LICENSE_KEY!;
  const isProduction = process.env.NODE_ENV === "production";

  const tokenResult = await verifyToken(tokenParam, secret, licenseKey);
  if (!tokenResult) {
    return NextResponse.redirect("/login");
  }

  const { payload } = tokenResult;
  const role = extractRoleFromPayload(payload, "myservice", "ADMIN");

  const jwt = createNextAuthJWT(payload, "myservice");
  const sessionToken = await encodeNextAuthToken(jwt, secret);

  const redirectPath = role === "ADMIN" ? "/admin" : "/dashboard";
  const html = createRedirectHTML(redirectPath, "myservice");

  const response = new NextResponse(html, {
    status: 200,
    headers: { "Content-Type": "text/html" },
  });

  setCustomTokens(response, tokenParam, {
    cookiePrefix: "myservice",
    isProduction,
  });

  setNextAuthToken(response, sessionToken, {
    isProduction,
    cookieDomain: process.env.COOKIE_DOMAIN,
  });

  return response;
}

import { withAuth } from "next-auth/middleware";
import { NextRequest, NextResponse } from "next/server";
import { getToken } from "next-auth/jwt";
import {
  createMiddlewareConfig,
  handleMiddleware,
} from "@thinkingcat/auth-utils";

const middlewareConfig = createMiddlewareConfig({
  serviceId: "myservice",
  publicPaths: ["/login", "/register", "/api/public"],
  subscriptionRequiredPaths: ["/premium"],
  roleAccessConfig: [
    {
      paths: ["/admin"],
      role: "ADMIN",
      message: "관리자만 접근할 수 있습니다.",
    },
  ],
  rolePaths: {
    ADMIN: "/admin",
    USER: "/dashboard",
  },
});

export default withAuth(
  async function middleware(req: NextRequest) {
    const response = await handleMiddleware(req, middlewareConfig, {
      secret: process.env.NEXTAUTH_SECRET!,
      isProduction: process.env.NODE_ENV === "production",
      cookieDomain: process.env.COOKIE_DOMAIN,
      ssoBaseURL: process.env.SSO_BASE_URL!,
      getNextAuthToken: async (req: NextRequest) => {
        return await getToken({ req, secret: process.env.NEXTAUTH_SECRET! });
      },
      authServiceKey: process.env.AUTH_SERVICE_SECRET_KEY,
    });
    return response || NextResponse.next();
  },
  {
    callbacks: {
      authorized: () => true,
    },
  }
);

export const config = {
  matcher: ["/((?!_next/static|_next/image|favicon.ico).*)"],
};

interface JWTPayload {
  // 표준 JWT 필드
  sub?: string; // Subject (사용자 ID)
  id?: string; // 사용자 ID
  email: string; // 이메일
  name: string; // 이름
  role?: string; // 역할
  iat?: number; // Issued At
  exp?: number; // Expiration Time

  // 서비스 정보
  services?: ServiceInfo[];

  // 인증 상태
  phoneVerified?: boolean;
  emailVerified?: boolean;
  smsVerified?: boolean;

  // 선택적 필드
  phone?: string;
  isPasswordReset?: boolean;
  decryptedEmail?: string;
  decryptedPhone?: string;
  emailHash?: string;
  maskedEmail?: string;
  phoneHash?: string;
  maskedPhone?: string;
  refreshToken?: string;
  accessToken?: string;
  accessTokenExpires?: number;
  serviceId?: string;

  // 기타 필드
  [key: string]: unknown;
}

interface ServiceInfo {
  serviceId: string;
  role: string;
  joinedAt: string;
  lastAccessAt?: string;
  expiredAt?: string;
  status: string;
}

interface MiddlewareConfig {
  serviceId: string;
  publicPaths: string[];
  subscriptionRequiredPaths: string[];
  subscriptionExemptApiPaths: string[];
  authApiPaths: string[];
  roleAccessConfig: RoleAccessConfig[];
  rolePaths: Record<string, string>;
  systemAdminRole: string;
  errorPath: string;
}

interface MiddlewareOptions {
  secret: string;
  isProduction: boolean;
  cookieDomain?: string;
  getNextAuthToken?: (req: NextRequest) => Promise<JWT | null>;
  ssoBaseURL: string;
  authServiceKey?: string;
  licenseKey: string;
}

interface RoleAccessConfig {
  paths: string[];
  role: string;
  allowedRoles?: string[];
  message?: string;
}

interface SSORefreshTokenResponse {
  success: boolean;
  accessToken?: string;
  refreshToken?: string;
  user?: {
    id: string;
    email: string;
    name: string;
  };
  error?: string;
}

interface SSOGetRefreshTokenResponse {
  success: boolean;
  refreshToken?: string;
  error?: string;
}

interface ResponseLike {
  cookies: {
    delete(name: string): void;
    set(
      name: string,
      value: string,
      options?: {
        httpOnly?: boolean;
        secure?: boolean;
        sameSite?: "strict" | "lax" | "none";
        maxAge?: number;
        path?: string;
        domain?: string;
      }
    ): void;
  };
}

const ssoBaseURL = process.env.SSO_BASE_URL!;
if (!ssoBaseURL) {
  throw new Error("SSO_BASE_URL environment variable is required");
}

const cookiePrefix = "myservice"; // 서비스별로 변경
setCustomTokens(response, accessToken, {
  cookiePrefix, // 필수
  isProduction: true,
});

const licenseKey = process.env.LICENSE_KEY;
if (!licenseKey) {
  throw new Error("LICENSE_KEY environment variable is required");
}

// 함수 호출 시 licenseKey 전달
const response = await handleMiddleware(req, middlewareConfig, {
  secret: process.env.NEXTAUTH_SECRET!,
  licenseKey, // 필수
  ssoBaseURL: process.env.SSO_BASE_URL!,
  // ... 기타 옵션
});