세션 관리

// server.ts (개발 환경)
import fastify from "fastify";
import fastifySession from "@fastify/session";
import fastifyCookie from "@fastify/cookie";

const app = fastify();

app.register(fastifyCookie);

app.register(fastifySession, {
  secret: process.env.SESSION_SECRET!,
  cookie: {
    secure: false, // 개발 환경에서는 HTTP 허용
    httpOnly: true,
    maxAge: 1000 * 60 * 60 * 24, // 1일
  },
  saveUninitialized: false,
  // store를 지정하지 않으면 메모리 스토어 사용
});

npm install @fastify/redis connect-redis
# or
pnpm add @fastify/redis connect-redis

// server.ts (프로덕션)
import fastify from "fastify";
import fastifySession from "@fastify/session";
import fastifyCookie from "@fastify/cookie";
import fastifyRedis from "@fastify/redis";
import RedisStore from "connect-redis";

const app = fastify();

// Redis 연결
app.register(fastifyRedis, {
  host: process.env.REDIS_HOST || "localhost",
  port: parseInt(process.env.REDIS_PORT || "6379"),
  password: process.env.REDIS_PASSWORD,
  // 연결 풀 설정
  lazyConnect: false,
  enableReadyCheck: true,
});

app.register(fastifyCookie);

// Redis를 세션 스토어로 사용
app.register(fastifySession, {
  secret: process.env.SESSION_SECRET!,
  store: new RedisStore({
    client: app.redis, // Fastify Redis 클라이언트 사용
    prefix: "sess:", // 세션 키 접두사
    ttl: 60 * 60 * 24 * 7, // 7일 (초 단위)
  }),
  cookie: {
    secure: true, // HTTPS 필수
    httpOnly: true, // XSS 방지
    sameSite: "strict", // CSRF 방지
    maxAge: 1000 * 60 * 60 * 24 * 7, // 7일
  },
  saveUninitialized: false,
  resave: false,
});

npm install connect-pg-simple
# or
pnpm add connect-pg-simple

import session from "express-session";
import connectPgSimple from "connect-pg-simple";
import pg from "pg";

const PgStore = connectPgSimple(session);
const pgPool = new pg.Pool({
  host: process.env.DB_HOST,
  port: parseInt(process.env.DB_PORT || "5432"),
  user: process.env.DB_USER,
  password: process.env.DB_PASSWORD,
  database: process.env.DB_NAME,
});

app.register(fastifySession, {
  secret: process.env.SESSION_SECRET!,
  store: new PgStore({
    pool: pgPool,
    tableName: "sessions", // 세션 테이블명
  }),
  cookie: {
    secure: true,
    httpOnly: true,
    maxAge: 1000 * 60 * 60 * 24 * 7,
  },
});

app.register(fastifySession, {
  secret: process.env.SESSION_SECRET!,
  cookie: {
    maxAge: 1000 * 60 * 60 * 2, // 2시간 후 무조건 만료
  },
  rolling: false, // 슬라이딩 만료 비활성화
});

app.register(fastifySession, {
  secret: process.env.SESSION_SECRET!,
  cookie: {
    maxAge: 1000 * 60 * 60 * 24 * 7, // 7일
  },
  rolling: true, // 매 요청마다 만료 시간 갱신
  resave: false, // 세션이 변경되지 않아도 저장
});

class AuthModel extends BaseModelClass {
  @api({ httpMethod: "POST" })
  async login(params: {
    email: string;
    password: string;
    rememberMe?: boolean;
  }): Promise<{ user: User }> {
    const { email, password, rememberMe } = params;
    const context = Sonamu.getContext();
    
    // 인증 로직...
    const user = await this.authenticateUser(email, password);
    
    // Remember Me에 따라 세션 만료 시간 조정
    if (rememberMe) {
      context.request.session.cookie.maxAge = 1000 * 60 * 60 * 24 * 30; // 30일
    } else {
      context.request.session.cookie.maxAge = 1000 * 60 * 60 * 2; // 2시간
    }
    
    // 세션에 로그인 정보 저장
    await this.loginToSession(user);
    
    return { user };
  }
}

// ✅ 좋은 예: 최소 정보만 저장
context.request.session.userId = user.id;
context.request.session.role = user.role;

// ❌ 나쁜 예: 너무 많은 정보 저장
context.request.session.user = {
  id: user.id,
  email: user.email,
  username: user.username,
  bio: user.bio,
  profileImage: user.profileImage,
  preferences: user.preferences,
  // ... 수많은 필드
};

class UserModel extends BaseModelClass {
  @api({ httpMethod: "GET" })
  async getProfile(): Promise<{ user: User }> {
    const context = Sonamu.getContext();
    
    // 세션에서 사용자 ID 가져오기
    const userId = context.request.session.userId;
    
    if (!userId) {
      throw new Error("Not authenticated");
    }
    
    // 데이터베이스에서 최신 정보 조회
    const rdb = this.getPuri("r");
    const user = await rdb
      .table("users")
      .where("id", userId)
      .first();
    
    return { user };
  }
}

header.payload.signature

// auth/jwt.ts
import jwt from "jsonwebtoken";

const ACCESS_TOKEN_SECRET = process.env.ACCESS_TOKEN_SECRET!;
const REFRESH_TOKEN_SECRET = process.env.REFRESH_TOKEN_SECRET!;

/**
 * Access Token 생성 (짧은 수명)
 */
export function generateAccessToken(user: User): string {
  return jwt.sign(
    {
      userId: user.id,
      email: user.email,
      role: user.role,
    },
    ACCESS_TOKEN_SECRET,
    {
      expiresIn: "15m", // 15분
    }
  );
}

/**
 * Refresh Token 생성 (긴 수명)
 */
export function generateRefreshToken(user: User): string {
  return jwt.sign(
    {
      userId: user.id,
      // Refresh Token에는 최소 정보만
    },
    REFRESH_TOKEN_SECRET,
    {
      expiresIn: "7d", // 7일
    }
  );
}

/**
 * Access Token 검증
 */
export function verifyAccessToken(token: string) {
  try {
    return jwt.verify(token, ACCESS_TOKEN_SECRET);
  } catch (error) {
    return null;
  }
}

/**
 * Refresh Token 검증
 */
export function verifyRefreshToken(token: string) {
  try {
    return jwt.verify(token, REFRESH_TOKEN_SECRET);
  } catch (error) {
    return null;
  }
}

CREATE TABLE refresh_tokens (
  id SERIAL PRIMARY KEY,
  user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
  token TEXT NOT NULL UNIQUE,
  expires_at TIMESTAMP NOT NULL,
  created_at TIMESTAMP DEFAULT NOW(),
  
  INDEX idx_user_id (user_id),
  INDEX idx_token (token),
  INDEX idx_expires_at (expires_at)
);

class AuthModel extends BaseModelClass {
  /**
   * Access Token 갱신
   * 
   * Refresh Token을 받아 새로운 Access Token을 발급합니다.
   * Refresh Token의 유효성과 데이터베이스 저장 여부를 모두 확인합니다.
   */
  @api({ httpMethod: "POST" })
  async refreshToken(params: {
    refreshToken: string;
  }): Promise<{
    accessToken: string;
    refreshToken?: string; // Refresh Token Rotation 시
  }> {
    const { refreshToken } = params;
    
    // 1. Refresh Token 검증
    const payload = verifyRefreshToken(refreshToken);
    
    if (!payload || typeof payload === "string") {
      throw new Error("Invalid refresh token");
    }
    
    // 2. 데이터베이스에서 Refresh Token 확인
    const rdb = this.getPuri("r");
    const storedToken = await rdb
      .table("refresh_tokens")
      .where("token", refreshToken)
      .where("user_id", payload.userId)
      .where("expires_at", ">", new Date())
      .first();
    
    if (!storedToken) {
      throw new Error("Refresh token not found or expired");
    }
    
    // 3. 사용자 정보 조회
    const user = await rdb
      .table("users")
      .where("id", payload.userId)
      .first();
    
    if (!user) {
      throw new Error("User not found");
    }
    
    // 4. 새 Access Token 생성
    const accessToken = generateAccessToken(user);
    
    // 5. Refresh Token Rotation (선택사항)
    // 보안 강화를 위해 Refresh Token도 함께 갱신
    const newRefreshToken = generateRefreshToken(user);
    
    const wdb = this.getPuri("w");
    
    // 기존 Refresh Token 삭제
    await wdb
      .table("refresh_tokens")
      .where("token", refreshToken)
      .delete();
    
    // 새 Refresh Token 저장
    await wdb.table("refresh_tokens").insert({
      user_id: user.id,
      token: newRefreshToken,
      expires_at: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000), // 7일
    });
    
    return {
      accessToken,
      refreshToken: newRefreshToken,
    };
  }
}

class AuthModel extends BaseModelClass {
  /**
   * 로그아웃
   * 
   * Refresh Token을 데이터베이스에서 삭제하고,
   * Access Token을 블랙리스트에 추가합니다.
   */
  @api({ httpMethod: "POST" })
  async logout(): Promise<{ success: boolean }> {
    const context = Sonamu.getContext();
    
    if (!context.user) {
      throw new Error("Not authenticated");
    }
    
    const wdb = this.getPuri("w");
    
    // 1. 모든 Refresh Token 삭제
    await wdb
      .table("refresh_tokens")
      .where("user_id", context.user.id)
      .delete();
    
    // 2. 현재 Access Token을 블랙리스트에 추가
    const authHeader = context.request.headers.authorization;
    if (authHeader && authHeader.startsWith("Bearer ")) {
      const token = authHeader.substring(7);
      
      // Access Token의 남은 유효시간 계산
      const decoded = jwt.decode(token) as any;
      const expiresIn = decoded.exp - Math.floor(Date.now() / 1000);
      
      // Redis에 블랙리스트 추가 (TTL은 토큰 남은 시간)
      const redis = getRedisClient();
      await redis.setex(`blacklist:${token}`, expiresIn, "1");
    }
    
    return { success: true };
  }
  
  /**
   * 모든 세션 로그아웃 (다른 기기 포함)
   */
  @api({ httpMethod: "POST" })
  async logoutAll(): Promise<{ success: boolean }> {
    const context = Sonamu.getContext();
    
    if (!context.user) {
      throw new Error("Not authenticated");
    }
    
    const wdb = this.getPuri("w");
    
    // 모든 Refresh Token 삭제
    await wdb
      .table("refresh_tokens")
      .where("user_id", context.user.id)
      .delete();
    
    return { success: true };
  }
}

// auth/jwt.middleware.ts
import type { FastifyRequest, FastifyReply } from "fastify";

export async function checkTokenBlacklist(
  request: FastifyRequest,
  reply: FastifyReply
) {
  const authHeader = request.headers.authorization;
  
  if (!authHeader || !authHeader.startsWith("Bearer ")) {
    return;
  }
  
  const token = authHeader.substring(7);
  
  // Redis에서 블랙리스트 확인
  const redis = getRedisClient();
  const isBlacklisted = await redis.exists(`blacklist:${token}`);
  
  if (isBlacklisted) {
    return reply.status(401).send({
      error: "Token has been revoked",
    });
  }
}

class AuthModel extends BaseModelClass {
  @api({ httpMethod: "POST" })
  async login(params: {
    email: string;
    password: string;
  }): Promise<{ accessToken: string }> {
    const { email, password } = params;
    
    // 인증...
    const user = await this.authenticateUser(email, password);
    
    const wdb = this.getPuri("w");
    
    // 기존 세션 모두 삭제 (강제 로그아웃)
    await wdb
      .table("refresh_tokens")
      .where("user_id", user.id)
      .delete();
    
    // 새 토큰 발급
    const accessToken = generateAccessToken(user);
    const refreshToken = generateRefreshToken(user);
    
    await wdb.table("refresh_tokens").insert({
      user_id: user.id,
      token: refreshToken,
      expires_at: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000),
    });
    
    return { accessToken };
  }
}

// tasks/cleanup-tokens.ts
import { task } from "sonamu";

/**
 * 매일 자정에 만료된 Refresh Token 삭제
 */
@task({ cron: "0 0 * * *" })
export async function cleanupExpiredTokens() {
  const db = getDatabase();
  
  const result = await db
    .table("refresh_tokens")
    .where("expires_at", "<", new Date())
    .delete();
  
  console.log(`Deleted ${result} expired refresh tokens`);
}