feat: 인센티브 시스템 구현 및 타입 정의 추가

src/graphql/resolvers.ts

@@ -15,27 +15,21 @@ interface PostInput {
 }
 
 type PubSubEvents = {
-  [K in 'POST_CREATED' | 'POST_UPDATED' | 'POST_DELETED' | 'COMMIT_CREATED' | '_PING']: K extends '_PING'
-    ? boolean
-    : K extends 'POST_DELETED'
-    ? string
-    : K extends 'COMMIT_CREATED'
-    ? any
-    : Post;
-};
-
-interface PubSubEvents {
+  POST_CREATED: Post;
+  POST_UPDATED: Post;
+  POST_DELETED: Post;
+  PING: { timestamp: number };
   USER_POINTS_UPDATED: { userPointsUpdated: User };
   NEW_NFT_MINTED: { newNFTMinted: NFT };
   CONTRIBUTION_STATUS_CHANGED: { contributionStatusChanged: Contribution };
   LEADERBOARD_UPDATED: { leaderboardUpdated: LeaderboardEntry[] };
-}
+};
 
-const pubsub = new PubSub<PubSubEvents>();
+const pubSub = createPubSub<PubSubEvents>();
 
 const startPingInterval = () => {
   setInterval(() => {
-    pubsub.publish('_PING', true);
+    pubSub.publish('PING', { timestamp: Date.now() });
   }, 5000);
 };
 
@@ -138,7 +132,7 @@ export const resolvers = {
     createPost: async (_: unknown, { input }: { input: PostInput }) => {
       try {
         const post = await createPost(input);
-        await pubsub.publish('POST_CREATED', post);
+        await pubSub.publish('POST_CREATED', post);
         return post;
       } catch (error) {
         console.error('Error creating post:', error);
@@ -148,7 +142,9 @@ export const resolvers = {
     updatePost: async (_: unknown, { id, input }: { id: string; input: PostInput }) => {
       try {
         const post = await updatePost(id, input);
-        await pubsub.publish('POST_UPDATED', post);
+        if (post) {
+          await pubSub.publish('POST_UPDATED', post);
+        }
         return post;
       } catch (error) {
         console.error('Error updating post:', error);
@@ -158,7 +154,9 @@ export const resolvers = {
     deletePost: async (_: unknown, { id }: { id: string }) => {
       try {
         const post = await deletePost(id);
-        await pubsub.publish('POST_DELETED', post);
+        if (post) {
+          await pubSub.publish('POST_DELETED', post);
+        }
         return post;
       } catch (error) {
         console.error('Error deleting post:', error);
@@ -190,7 +188,7 @@ export const resolvers = {
         createdAt: new Date().toISOString(),
       };
       nfts.push(nft);
-      await pubsub.publish('NEW_NFT_MINTED', { newNFTMinted: nft });
+      await pubSub.publish('NEW_NFT_MINTED', { newNFTMinted: nft });
       return nft;
     },
     createContribution: async (_: any, { input }: { input: { userId: string; type: ContributionType; description: string } }) => {
@@ -222,14 +220,14 @@ export const resolvers = {
       if (user) {
         user.points += contribution.points;
         user.level = calculateLevel(user.points);
-        await pubsub.publish('USER_POINTS_UPDATED', { userPointsUpdated: user });
+        await pubSub.publish('USER_POINTS_UPDATED', { userPointsUpdated: user });
       }
 
       // 리더보드 업데이트
       const leaderboard = updateLeaderboard();
-      await pubsub.publish('LEADERBOARD_UPDATED', { leaderboardUpdated: leaderboard });
+      await pubSub.publish('LEADERBOARD_UPDATED', { leaderboardUpdated: leaderboard });
 
-      await pubsub.publish('CONTRIBUTION_STATUS_CHANGED', { contributionStatusChanged: contribution });
+      await pubSub.publish('CONTRIBUTION_STATUS_CHANGED', { contributionStatusChanged: contribution });
       return contribution;
     },
     rejectContribution: async (_: any, { id }: { id: string }) => {
@@ -239,48 +237,54 @@ export const resolvers = {
         throw new Error('Contribution is not pending');
 
       contribution.status = ContributionStatus.REJECTED;
-      await pubsub.publish('CONTRIBUTION_STATUS_CHANGED', { contributionStatusChanged: contribution });
+      await pubSub.publish('CONTRIBUTION_STATUS_CHANGED', { contributionStatusChanged: contribution });
       return contribution;
     },
   },
 
   Subscription: {
     postCreated: {
-      subscribe: () => pubsub.subscribe('POST_CREATED'),
+      subscribe: () => pubSub.subscribe('POST_CREATED'),
       resolve: (payload: { postCreated: Post }) => payload.postCreated
     },
     
     postUpdated: {
-      subscribe: () => pubsub.subscribe('POST_UPDATED'),
+      subscribe: () => pubSub.subscribe('POST_UPDATED'),
       resolve: (payload: { postUpdated: Post }) => payload.postUpdated
     },
     
     postDeleted: {
-      subscribe: () => pubsub.subscribe('POST_DELETED'),
+      subscribe: () => pubSub.subscribe('POST_DELETED'),
       resolve: (payload: { postDeleted: string }) => payload.postDeleted
     },
     
-    commitCreated: {
-      subscribe: () => pubsub.subscribe('COMMIT_CREATED'),
-      resolve: (payload: any) => payload
-    },
-    
-    _ping: {
+    ping: {
       subscribe: () => {
         const interval = setInterval(() => {
-          pubsub.publish('_PING', { _ping: true });
+          pubSub.publish('PING', { timestamp: Date.now() });
         }, 5000);
         
-        return pubsub.subscribe('_PING');
-      },
-      resolve: (payload: { _ping: boolean }) => payload._ping
+        return {
+          [Symbol.asyncIterator]() {
+            return {
+              next() {
+                return Promise.resolve({ value: { timestamp: Date.now() }, done: false });
+              },
+              return() {
+                clearInterval(interval);
+                return Promise.resolve({ done: true });
+              }
+            };
+          }
+        };
+      }
     },
     userPointsUpdated: {
       subscribe: (_: any, { userId }: { userId: string }) => ({
         [Symbol.asyncIterator]: () => ({
           next: async () => {
             const user = await new Promise<User>(resolve => {
-              pubsub.subscribe('USER_POINTS_UPDATED', ({ userPointsUpdated }) => {
+              pubSub.subscribe('USER_POINTS_UPDATED', ({ userPointsUpdated }) => {
                 if (userPointsUpdated.id === userId) {
                   resolve(userPointsUpdated);
                 }
@@ -296,7 +300,7 @@ export const resolvers = {
         [Symbol.asyncIterator]: () => ({
           next: async () => {
             const nft = await new Promise<NFT>(resolve => {
-              pubsub.subscribe('NEW_NFT_MINTED', ({ newNFTMinted }) => {
+              pubSub.subscribe('NEW_NFT_MINTED', ({ newNFTMinted }) => {
                 if (newNFTMinted.owner.id === userId) {
                   resolve(newNFTMinted);
                 }
@@ -312,7 +316,7 @@ export const resolvers = {
         [Symbol.asyncIterator]: () => ({
           next: async () => {
             const contribution = await new Promise<Contribution>(resolve => {
-              pubsub.subscribe('CONTRIBUTION_STATUS_CHANGED', ({ contributionStatusChanged }) => {
+              pubSub.subscribe('CONTRIBUTION_STATUS_CHANGED', ({ contributionStatusChanged }) => {
                 if (contributionStatusChanged.user.id === userId) {
                   resolve(contributionStatusChanged);
                 }
@@ -324,7 +328,7 @@ export const resolvers = {
       }),
     },
     leaderboardUpdated: {
-      subscribe: () => pubsub.subscribe('LEADERBOARD_UPDATED'),
+      subscribe: () => pubSub.subscribe('LEADERBOARD_UPDATED'),
     },
   },
 }; 

src/lib/achievement.ts

@@ -0,0 +1,184 @@
+import { prisma } from './prisma';
+import { User, Contribution, ContributionType } from '../types/incentive';
+import { createNotification, NotificationType } from './notification';
+
+export interface Achievement {
+  id: string;
+  name: string;
+  description: string;
+  points: number;
+  type: AchievementType;
+  requirements: AchievementRequirement[];
+  icon: string;
+}
+
+export enum AchievementType {
+  CONTRIBUTION_COUNT = 'CONTRIBUTION_COUNT',
+  POINTS_TOTAL = 'POINTS_TOTAL',
+  NFT_COLLECTION = 'NFT_COLLECTION',
+  LEVEL_REACHED = 'LEVEL_REACHED',
+  SPECIAL = 'SPECIAL',
+}
+
+export interface AchievementRequirement {
+  type: AchievementType;
+  value: number;
+}
+
+export async function checkAchievements(userId: string): Promise<Achievement[]> {
+  try {
+    const user = await prisma.user.findUnique({
+      where: { id: userId },
+      include: {
+        contributions: true,
+        nfts: true,
+        achievements: true,
+      },
+    });
+
+    if (!user) {
+      throw new Error('User not found');
+    }
+
+    const allAchievements = await prisma.achievement.findMany();
+    const unlockedAchievements: Achievement[] = [];
+
+    for (const achievement of allAchievements) {
+      if (user.achievements.some(a => a.id === achievement.id)) {
+        continue;
+      }
+
+      if (await checkAchievementRequirements(user, achievement)) {
+        await unlockAchievement(userId, achievement);
+        unlockedAchievements.push(achievement);
+      }
+    }
+
+    return unlockedAchievements;
+  } catch (error) {
+    console.error('Error checking achievements:', error);
+    return [];
+  }
+}
+
+async function checkAchievementRequirements(
+  user: User & { contributions: Contribution[]; nfts: NFT[] },
+  achievement: Achievement
+): Promise<boolean> {
+  for (const requirement of achievement.requirements) {
+    switch (requirement.type) {
+      case AchievementType.CONTRIBUTION_COUNT:
+        if (user.contributions.length < requirement.value) {
+          return false;
+        }
+        break;
+      case AchievementType.POINTS_TOTAL:
+        if (user.points < requirement.value) {
+          return false;
+        }
+        break;
+      case AchievementType.NFT_COLLECTION:
+        if (user.nfts.length < requirement.value) {
+          return false;
+        }
+        break;
+      case AchievementType.LEVEL_REACHED:
+        if (user.level < requirement.value) {
+          return false;
+        }
+        break;
+    }
+  }
+  return true;
+}
+
+async function unlockAchievement(userId: string, achievement: Achievement): Promise<void> {
+  try {
+    await prisma.userAchievement.create({
+      data: {
+        userId,
+        achievementId: achievement.id,
+      },
+    });
+
+    await createNotification(
+      userId,
+      NotificationType.NEW_ACHIEVEMENT,
+      `Congratulations! You've unlocked the achievement: ${achievement.name}`,
+      { achievementId: achievement.id }
+    );
+  } catch (error) {
+    console.error('Error unlocking achievement:', error);
+    throw error;
+  }
+}
+
+export async function getUserAchievements(userId: string): Promise<Achievement[]> {
+  try {
+    const userAchievements = await prisma.userAchievement.findMany({
+      where: { userId },
+      include: { achievement: true },
+    });
+
+    return userAchievements.map(ua => ua.achievement);
+  } catch (error) {
+    console.error('Error getting user achievements:', error);
+    return [];
+  }
+}
+
+export async function getAchievementProgress(
+  userId: string,
+  achievementId: string
+): Promise<{ progress: number; total: number }> {
+  try {
+    const user = await prisma.user.findUnique({
+      where: { id: userId },
+      include: {
+        contributions: true,
+        nfts: true,
+      },
+    });
+
+    if (!user) {
+      throw new Error('User not found');
+    }
+
+    const achievement = await prisma.achievement.findUnique({
+      where: { id: achievementId },
+    });
+
+    if (!achievement) {
+      throw new Error('Achievement not found');
+    }
+
+    let progress = 0;
+    let total = 0;
+
+    for (const requirement of achievement.requirements) {
+      switch (requirement.type) {
+        case AchievementType.CONTRIBUTION_COUNT:
+          progress += user.contributions.length;
+          total += requirement.value;
+          break;
+        case AchievementType.POINTS_TOTAL:
+          progress += user.points;
+          total += requirement.value;
+          break;
+        case AchievementType.NFT_COLLECTION:
+          progress += user.nfts.length;
+          total += requirement.value;
+          break;
+        case AchievementType.LEVEL_REACHED:
+          progress += user.level;
+          total += requirement.value;
+          break;
+      }
+    }
+
+    return { progress, total };
+  } catch (error) {
+    console.error('Error getting achievement progress:', error);
+    throw error;
+  }
+} 

src/lib/ai.ts

@@ -0,0 +1,55 @@
+import { Configuration, OpenAIApi } from 'openai';
+
+const configuration = new Configuration({
+  apiKey: process.env.OPENAI_API_KEY,
+});
+
+const openai = new OpenAIApi(configuration);
+
+export async function generateCodeReview(code: string): Promise<string> {
+  try {
+    const response = await openai.createCompletion({
+      model: 'text-davinci-003',
+      prompt: `Please review the following code and provide suggestions for improvement:\n\n${code}`,
+      max_tokens: 500,
+      temperature: 0.7,
+    });
+
+    return response.data.choices[0].text || 'No review available';
+  } catch (error) {
+    console.error('Error generating code review:', error);
+    return 'Error generating code review';
+  }
+}
+
+export async function generateCommitMessage(diff: string): Promise<string> {
+  try {
+    const response = await openai.createCompletion({
+      model: 'text-davinci-003',
+      prompt: `Generate a concise commit message for the following changes:\n\n${diff}`,
+      max_tokens: 100,
+      temperature: 0.7,
+    });
+
+    return response.data.choices[0].text || 'Update';
+  } catch (error) {
+    console.error('Error generating commit message:', error);
+    return 'Update';
+  }
+}
+
+export async function generateCodeSuggestion(prompt: string): Promise<string> {
+  try {
+    const response = await openai.createCompletion({
+      model: 'text-davinci-003',
+      prompt: `Generate code based on the following description:\n\n${prompt}`,
+      max_tokens: 500,
+      temperature: 0.7,
+    });
+
+    return response.data.choices[0].text || 'No suggestion available';
+  } catch (error) {
+    console.error('Error generating code suggestion:', error);
+    return 'Error generating code suggestion';
+  }
+} 

src/lib/analytics.ts

@@ -0,0 +1,126 @@
+import { prisma } from './prisma';
+import { Contribution, ContributionType, User } from '../types/incentive';
+
+export async function trackContribution(
+  userId: string,
+  type: ContributionType,
+  points: number,
+  description: string
+): Promise<Contribution> {
+  try {
+    const contribution = await prisma.contribution.create({
+      data: {
+        userId,
+        type,
+        points,
+        description,
+        status: 'PENDING',
+      },
+      include: {
+        user: true,
+      },
+    });
+
+    await updateUserPoints(userId, points);
+
+    return contribution;
+  } catch (error) {
+    console.error('Error tracking contribution:', error);
+    throw error;
+  }
+}
+
+export async function updateUserPoints(userId: string, points: number): Promise<User> {
+  try {
+    const user = await prisma.user.update({
+      where: { id: userId },
+      data: {
+        points: {
+          increment: points,
+        },
+      },
+    });
+
+    await updateUserLevel(userId);
+
+    return user;
+  } catch (error) {
+    console.error('Error updating user points:', error);
+    throw error;
+  }
+}
+
+export async function updateUserLevel(userId: string): Promise<User> {
+  try {
+    const user = await prisma.user.findUnique({
+      where: { id: userId },
+    });
+
+    if (!user) {
+      throw new Error('User not found');
+    }
+
+    const level = Math.floor(Math.sqrt(user.points / 100)) + 1;
+
+    return await prisma.user.update({
+      where: { id: userId },
+      data: { level },
+    });
+  } catch (error) {
+    console.error('Error updating user level:', error);
+    throw error;
+  }
+}
+
+export async function getLeaderboard(): Promise<User[]> {
+  try {
+    const users = await prisma.user.findMany({
+      orderBy: {
+        points: 'desc',
+      },
+      take: 100,
+    });
+
+    return users.map((user, index) => ({
+      ...user,
+      rank: index + 1,
+    }));
+  } catch (error) {
+    console.error('Error getting leaderboard:', error);
+    return [];
+  }
+}
+
+export async function getUserStats(userId: string): Promise<{
+  totalPoints: number;
+  contributionCount: number;
+  nftCount: number;
+  rank: number;
+}> {
+  try {
+    const user = await prisma.user.findUnique({
+      where: { id: userId },
+      include: {
+        contributions: true,
+        nfts: true,
+      },
+    });
+
+    if (!user) {
+      throw new Error('User not found');
+    }
+
+    const leaderboard = await getLeaderboard();
+    const rank = leaderboard.findIndex(u => u.id === userId) + 1;
+
+    return {
+      totalPoints: user.points,
+      contributionCount: user.contributions.length,
+      nftCount: user.nfts.length,
+      rank,
+    };
+  } catch (error) {
+    console.error('Error getting user stats:', error);
+    throw error;
+  }
+} 

src/lib/auth.ts

@@ -0,0 +1 @@
+ 

src/lib/blockchain.ts

@@ -0,0 +1 @@
+ 

src/lib/cache.ts

@@ -0,0 +1,118 @@
+import { CACHE_CONFIG } from './config';
+
+interface CacheItem<T> {
+  value: T;
+  expiry: number;
+}
+
+class Cache {
+  private static instance: Cache;
+  private cache: Map<string, CacheItem<any>>;
+  private maxItems: number;
+
+  private constructor() {
+    this.cache = new Map();
+    this.maxItems = CACHE_CONFIG.MAX_ITEMS;
+  }
+
+  public static getInstance(): Cache {
+    if (!Cache.instance) {
+      Cache.instance = new Cache();
+    }
+    return Cache.instance;
+  }
+
+  public set<T>(key: string, value: T, ttl: number = CACHE_CONFIG.TTL): void {
+    if (this.cache.size >= this.maxItems) {
+      this.evictExpiredItems();
+      if (this.cache.size >= this.maxItems) {
+        const oldestKey = this.cache.keys().next().value;
+        this.cache.delete(oldestKey);
+      }
+    }
+
+    this.cache.set(key, {
+      value,
+      expiry: Date.now() + ttl,
+    });
+  }
+
+  public get<T>(key: string): T | null {
+    const item = this.cache.get(key);
+    if (!item) {
+      return null;
+    }
+
+    if (Date.now() > item.expiry) {
+      this.cache.delete(key);
+      return null;
+    }
+
+    return item.value as T;
+  }
+
+  public delete(key: string): void {
+    this.cache.delete(key);
+  }
+
+  public clear(): void {
+    this.cache.clear();
+  }
+
+  public has(key: string): boolean {
+    const item = this.cache.get(key);
+    if (!item) {
+      return false;
+    }
+
+    if (Date.now() > item.expiry) {
+      this.cache.delete(key);
+      return false;
+    }
+
+    return true;
+  }
+
+  public size(): number {
+    this.evictExpiredItems();
+    return this.cache.size;
+  }
+
+  private evictExpiredItems(): void {
+    const now = Date.now();
+    for (const [key, item] of this.cache.entries()) {
+      if (now > item.expiry) {
+        this.cache.delete(key);
+      }
+    }
+  }
+}
+
+export const cache = Cache.getInstance();
+
+export async function withCache<T>(
+  key: string,
+  fn: () => Promise<T>,
+  ttl: number = CACHE_CONFIG.TTL
+): Promise<T> {
+  const cachedValue = cache.get<T>(key);
+  if (cachedValue !== null) {
+    return cachedValue;
+  }
+
+  const value = await fn();
+  cache.set(key, value, ttl);
+  return value;
+}
+
+export function invalidateCache(pattern: string): void {
+  for (const key of cache['cache'].keys()) {
+    if (key.includes(pattern)) {
+      cache.delete(key);
+    }
+  }
+}
+
+export function clearCache(): void {
+  cache.clear();
+} 

src/lib/config.ts

@@ -0,0 +1,80 @@
+export const APP_NAME = 'AI Tree Portal';
+export const APP_DESCRIPTION = 'AI Tree Portal은 개발자들을 위한 커뮤니티 플랫폼입니다.';
+
+export const API_BASE_URL = process.env.NEXT_PUBLIC_API_BASE_URL || 'http://localhost:3000/api';
+export const WS_BASE_URL = process.env.NEXT_PUBLIC_WS_BASE_URL || 'ws://localhost:3000';
+
+export const POINTS_CONFIG = {
+  POST_CREATION: 10,
+  COMMENT: 5,
+  REVIEW: 15,
+  BUG_REPORT: 20,
+  FEATURE_SUGGESTION: 15,
+  CODE_CONTRIBUTION: 30,
+};
+
+export const LEVEL_CONFIG = {
+  BASE_POINTS: 100,
+  LEVEL_MULTIPLIER: 1.5,
+  MAX_LEVEL: 100,
+};
+
+export const NFT_CONFIG = {
+  MINT_COST: 1000,
+  RARITY_WEIGHTS: {
+    common: 0.6,
+    rare: 0.25,
+    epic: 0.1,
+    legendary: 0.05,
+  },
+};
+
+export const ACHIEVEMENT_CONFIG = {
+  CONTRIBUTION_MILESTONES: [10, 50, 100, 500, 1000],
+  POINTS_MILESTONES: [1000, 5000, 10000, 50000, 100000],
+  NFT_MILESTONES: [1, 5, 10, 25, 50],
+  LEVEL_MILESTONES: [10, 20, 30, 40, 50],
+};
+
+export const RATE_LIMIT_CONFIG = {
+  MAX_REQUESTS: 100,
+  WINDOW_MS: 15 * 60 * 1000, // 15 minutes
+};
+
+export const CACHE_CONFIG = {
+  TTL: 5 * 60 * 1000, // 5 minutes
+  MAX_ITEMS: 1000,
+};
+
+export const SECURITY_CONFIG = {
+  PASSWORD_MIN_LENGTH: 8,
+  PASSWORD_REQUIREMENTS: {
+    UPPERCASE: true,
+    LOWERCASE: true,
+    NUMBERS: true,
+    SPECIAL_CHARS: true,
+  },
+  SESSION_DURATION: 24 * 60 * 60 * 1000, // 24 hours
+  TOKEN_EXPIRY: 7 * 24 * 60 * 60 * 1000, // 7 days
+};
+
+export const UI_CONFIG = {
+  PAGINATION_LIMIT: 10,
+  MAX_FILE_SIZE: 5 * 1024 * 1024, // 5MB
+  ALLOWED_FILE_TYPES: ['image/jpeg', 'image/png', 'image/gif'],
+  MAX_TITLE_LENGTH: 100,
+  MAX_DESCRIPTION_LENGTH: 1000,
+  MAX_COMMENT_LENGTH: 500,
+};
+
+export const ANALYTICS_CONFIG = {
+  ENABLED: process.env.NEXT_PUBLIC_ANALYTICS_ENABLED === 'true',
+  TRACKING_ID: process.env.NEXT_PUBLIC_ANALYTICS_TRACKING_ID,
+};
+
+export const FEATURE_FLAGS = {
+  ENABLE_NFT_MINTING: process.env.NEXT_PUBLIC_ENABLE_NFT_MINTING === 'true',
+  ENABLE_ACHIEVEMENTS: process.env.NEXT_PUBLIC_ENABLE_ACHIEVEMENTS === 'true',
+  ENABLE_LEADERBOARD: process.env.NEXT_PUBLIC_ENABLE_LEADERBOARD === 'true',
+  ENABLE_NOTIFICATIONS: process.env.NEXT_PUBLIC_ENABLE_NOTIFICATIONS === 'true',
+}; 

src/lib/error.ts

@@ -0,0 +1,103 @@
+export class AppError extends Error {
+  constructor(
+    public message: string,
+    public statusCode: number = 500,
+    public code?: string
+  ) {
+    super(message);
+    this.name = 'AppError';
+  }
+}
+
+export class ValidationError extends AppError {
+  constructor(message: string) {
+    super(message, 400, 'VALIDATION_ERROR');
+    this.name = 'ValidationError';
+  }
+}
+
+export class AuthenticationError extends AppError {
+  constructor(message: string = '인증에 실패했습니다.') {
+    super(message, 401, 'AUTHENTICATION_ERROR');
+    this.name = 'AuthenticationError';
+  }
+}
+
+export class AuthorizationError extends AppError {
+  constructor(message: string = '권한이 없습니다.') {
+    super(message, 403, 'AUTHORIZATION_ERROR');
+    this.name = 'AuthorizationError';
+  }
+}
+
+export class NotFoundError extends AppError {
+  constructor(message: string = '요청한 리소스를 찾을 수 없습니다.') {
+    super(message, 404, 'NOT_FOUND_ERROR');
+    this.name = 'NotFoundError';
+  }
+}
+
+export class ConflictError extends AppError {
+  constructor(message: string = '이미 존재하는 리소스입니다.') {
+    super(message, 409, 'CONFLICT_ERROR');
+    this.name = 'ConflictError';
+  }
+}
+
+export class DatabaseError extends AppError {
+  constructor(message: string = '데이터베이스 오류가 발생했습니다.') {
+    super(message, 500, 'DATABASE_ERROR');
+    this.name = 'DatabaseError';
+  }
+}
+
+export class ExternalServiceError extends AppError {
+  constructor(message: string = '외부 서비스 오류가 발생했습니다.') {
+    super(message, 502, 'EXTERNAL_SERVICE_ERROR');
+    this.name = 'ExternalServiceError';
+  }
+}
+
+export function handleError(error: unknown): AppError {
+  if (error instanceof AppError) {
+    return error;
+  }
+
+  if (error instanceof Error) {
+    return new AppError(error.message);
+  }
+
+  return new AppError('알 수 없는 오류가 발생했습니다.');
+}
+
+export function isAppError(error: unknown): error is AppError {
+  return error instanceof AppError;
+}
+
+export function isValidationError(error: unknown): error is ValidationError {
+  return error instanceof ValidationError;
+}
+
+export function isAuthenticationError(error: unknown): error is AuthenticationError {
+  return error instanceof AuthenticationError;
+}
+
+export function isAuthorizationError(error: unknown): error is AuthorizationError {
+  return error instanceof AuthorizationError;
+}
+
+export function isNotFoundError(error: unknown): error is NotFoundError {
+  return error instanceof NotFoundError;
+}
+
+export function isConflictError(error: unknown): error is ConflictError {
+  return error instanceof ConflictError;
+}
+
+export function isDatabaseError(error: unknown): error is DatabaseError {
+  return error instanceof DatabaseError;
+}
+
+export function isExternalServiceError(error: unknown): error is ExternalServiceError {
+  return error instanceof ExternalServiceError;
+} 

src/lib/git.ts

@@ -1,5 +1,10 @@
 'use client';
 
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+
 export interface Commit {
   hash: string;
   message: string;
@@ -15,39 +20,23 @@ export interface FileDiff {
 
 export async function getCommitHistory(): Promise<Commit[]> {
   try {
-    const response = await fetch('/api/git?action=history');
-    if (!response.ok) {
-      throw new Error('커밋 이력 조회 실패');
-    }
-    const data = await response.json();
-    return data.commits;
+    const { stdout } = await execAsync('git log --pretty=format:"%H|%s|%an|%ad" --date=iso');
+    return stdout.split('\n').map(line => {
+      const [hash, message, author, date] = line.split('|');
+      return { hash, message, author, date };
+    });
   } catch (error) {
-    console.error('커밋 이력 조회 실패:', error);
+    console.error('Error getting commit history:', error);
     return [];
   }
 }
 
 export async function rollbackToCommit(commitHash: string): Promise<boolean> {
   try {
-    const response = await fetch('/api/git', {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-      },
-      body: JSON.stringify({
-        action: 'rollback',
-        commitHash,
-      }),
-    });
-
-    if (!response.ok) {
-      throw new Error('롤백 실패');
-    }
-
-    const data = await response.json();
-    return data.success;
+    await execAsync(`git reset --hard ${commitHash}`);
+    return true;
   } catch (error) {
-    console.error('롤백 실패:', error);
+    console.error('Error rolling back to commit:', error);
     return false;
   }
 }
@@ -56,20 +45,13 @@ export async function getFileDiff(
   commitHash1: string,
   commitHash2: string,
   filePath: string
-): Promise<FileDiff> {
+): Promise<string> {
   try {
-    const response = await fetch(
-      `/api/git?action=diff&hash1=${commitHash1}&hash2=${commitHash2}&file=${encodeURIComponent(filePath)}`
-    );
-
-    if (!response.ok) {
-      throw new Error('파일 변경사항 비교 실패');
-    }
-
-    return await response.json();
+    const { stdout } = await execAsync(`git diff ${commitHash1} ${commitHash2} -- ${filePath}`);
+    return stdout;
   } catch (error) {
-    console.error('파일 변경사항 비교 실패:', error);
-    throw error;
+    console.error('Error getting file diff:', error);
+    return '';
   }
 }
 

src/lib/logger.ts

@@ -0,0 +1,92 @@
+import { AppError } from './error';
+
+export enum LogLevel {
+  DEBUG = 'DEBUG',
+  INFO = 'INFO',
+  WARN = 'WARN',
+  ERROR = 'ERROR',
+}
+
+export interface LogEntry {
+  timestamp: string;
+  level: LogLevel;
+  message: string;
+  error?: AppError;
+  metadata?: Record<string, any>;
+}
+
+class Logger {
+  private static instance: Logger;
+  private logLevel: LogLevel;
+
+  private constructor() {
+    this.logLevel = process.env.NODE_ENV === 'production' ? LogLevel.INFO : LogLevel.DEBUG;
+  }
+
+  public static getInstance(): Logger {
+    if (!Logger.instance) {
+      Logger.instance = new Logger();
+    }
+    return Logger.instance;
+  }
+
+  public setLogLevel(level: LogLevel): void {
+    this.logLevel = level;
+  }
+
+  private shouldLog(level: LogLevel): boolean {
+    const levels = Object.values(LogLevel);
+    return levels.indexOf(level) >= levels.indexOf(this.logLevel);
+  }
+
+  private formatLog(level: LogLevel, message: string, error?: AppError, metadata?: Record<string, any>): LogEntry {
+    return {
+      timestamp: new Date().toISOString(),
+      level,
+      message,
+      error,
+      metadata,
+    };
+  }
+
+  private log(level: LogLevel, message: string, error?: AppError, metadata?: Record<string, any>): void {
+    if (!this.shouldLog(level)) {
+      return;
+    }
+
+    const logEntry = this.formatLog(level, message, error, metadata);
+
+    switch (level) {
+      case LogLevel.DEBUG:
+        console.debug(JSON.stringify(logEntry));
+        break;
+      case LogLevel.INFO:
+        console.info(JSON.stringify(logEntry));
+        break;
+      case LogLevel.WARN:
+        console.warn(JSON.stringify(logEntry));
+        break;
+      case LogLevel.ERROR:
+        console.error(JSON.stringify(logEntry));
+        break;
+    }
+  }
+
+  public debug(message: string, metadata?: Record<string, any>): void {
+    this.log(LogLevel.DEBUG, message, undefined, metadata);
+  }
+
+  public info(message: string, metadata?: Record<string, any>): void {
+    this.log(LogLevel.INFO, message, undefined, metadata);
+  }
+
+  public warn(message: string, error?: AppError, metadata?: Record<string, any>): void {
+    this.log(LogLevel.WARN, message, error, metadata);
+  }
+
+  public error(message: string, error?: AppError, metadata?: Record<string, any>): void {
+    this.log(LogLevel.ERROR, message, error, metadata);
+  }
+}
+
+export const logger = Logger.getInstance(); 

src/lib/middleware.ts

@@ -0,0 +1,145 @@
+import { NextApiRequest, NextApiResponse } from 'next';
+import { AppError, handleError } from './error';
+import { logger } from './logger';
+import { validateEmail, validatePassword, validateUsername } from './validation';
+
+export type Middleware = (
+  req: NextApiRequest,
+  res: NextApiResponse,
+  next: () => void
+) => void | Promise<void>;
+
+export function errorHandler(): Middleware {
+  return async (req, res, next) => {
+    try {
+      await next();
+    } catch (error) {
+      const appError = handleError(error);
+      logger.error('Error occurred', appError, { path: req.url, method: req.method });
+
+      res.status(appError.statusCode).json({
+        error: {
+          message: appError.message,
+          code: appError.code,
+        },
+      });
+    }
+  };
+}
+
+export function loggerMiddleware(): Middleware {
+  return (req, res, next) => {
+    const start = Date.now();
+    res.on('finish', () => {
+      const duration = Date.now() - start;
+      logger.info('Request completed', {
+        method: req.method,
+        path: req.url,
+        status: res.statusCode,
+        duration: `${duration}ms`,
+      });
+    });
+    next();
+  };
+}
+
+export function validateAuth(): Middleware {
+  return (req, res, next) => {
+    const token = req.headers.authorization?.split(' ')[1];
+    if (!token) {
+      throw new AppError('인증 토큰이 필요합니다.', 401);
+    }
+    // TODO: 토큰 검증 로직 구현
+    next();
+  };
+}
+
+export function validateUserInput(): Middleware {
+  return (req, res, next) => {
+    if (req.method === 'POST' || req.method === 'PUT') {
+      const { email, password, username } = req.body;
+
+      if (email && !validateEmail(email)) {
+        throw new AppError('유효하지 않은 이메일 형식입니다.', 400);
+      }
+
+      if (password && !validatePassword(password)) {
+        throw new AppError(
+          '비밀번호는 최소 8자 이상이며, 대문자, 소문자, 숫자, 특수문자를 포함해야 합니다.',
+          400
+        );
+      }
+
+      if (username && !validateUsername(username)) {
+        throw new AppError(
+          '사용자 이름은 3-20자의 영문자, 숫자, 언더스코어만 사용할 수 있습니다.',
+          400
+        );
+      }
+    }
+    next();
+  };
+}
+
+export function corsMiddleware(): Middleware {
+  return (req, res, next) => {
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
+    res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+
+    if (req.method === 'OPTIONS') {
+      res.status(200).end();
+      return;
+    }
+
+    next();
+  };
+}
+
+export function rateLimitMiddleware(maxRequests: number, windowMs: number): Middleware {
+  const requests = new Map<string, { count: number; resetTime: number }>();
+
+  return (req, res, next) => {
+    const ip = req.headers['x-forwarded-for'] || req.socket.remoteAddress;
+    if (!ip) {
+      next();
+      return;
+    }
+
+    const now = Date.now();
+    const userRequests = requests.get(ip as string);
+
+    if (!userRequests || now > userRequests.resetTime) {
+      requests.set(ip as string, {
+        count: 1,
+        resetTime: now + windowMs,
+      });
+      next();
+      return;
+    }
+
+    if (userRequests.count >= maxRequests) {
+      throw new AppError('요청 횟수가 초과되었습니다. 잠시 후 다시 시도해주세요.', 429);
+    }
+
+    userRequests.count++;
+    next();
+  };
+}
+
+export function applyMiddlewares(...middlewares: Middleware[]): Middleware {
+  return async (req, res, next) => {
+    let index = 0;
+
+    const runNext = async () => {
+      if (index < middlewares.length) {
+        const middleware = middlewares[index++];
+        await middleware(req, res, runNext);
+      } else {
+        await next();
+      }
+    };
+
+    await runNext();
+  };
+} 

src/lib/notification.ts

@@ -0,0 +1,112 @@
+import { prisma } from './prisma';
+import { Contribution, NFT, User } from '../types/incentive';
+
+export interface Notification {
+  id: string;
+  userId: string;
+  type: NotificationType;
+  message: string;
+  read: boolean;
+  createdAt: string;
+  metadata?: any;
+}
+
+export enum NotificationType {
+  CONTRIBUTION_APPROVED = 'CONTRIBUTION_APPROVED',
+  CONTRIBUTION_REJECTED = 'CONTRIBUTION_REJECTED',
+  NFT_MINTED = 'NFT_MINTED',
+  LEVEL_UP = 'LEVEL_UP',
+  RANK_CHANGE = 'RANK_CHANGE',
+  NEW_ACHIEVEMENT = 'NEW_ACHIEVEMENT',
+}
+
+export async function createNotification(
+  userId: string,
+  type: NotificationType,
+  message: string,
+  metadata?: any
+): Promise<Notification> {
+  try {
+    return await prisma.notification.create({
+      data: {
+        userId,
+        type,
+        message,
+        read: false,
+        metadata,
+      },
+    });
+  } catch (error) {
+    console.error('Error creating notification:', error);
+    throw error;
+  }
+}
+
+export async function getUnreadNotifications(userId: string): Promise<Notification[]> {
+  try {
+    return await prisma.notification.findMany({
+      where: {
+        userId,
+        read: false,
+      },
+      orderBy: {
+        createdAt: 'desc',
+      },
+    });
+  } catch (error) {
+    console.error('Error getting unread notifications:', error);
+    return [];
+  }
+}
+
+export async function markNotificationAsRead(notificationId: string): Promise<Notification> {
+  try {
+    return await prisma.notification.update({
+      where: { id: notificationId },
+      data: { read: true },
+    });
+  } catch (error) {
+    console.error('Error marking notification as read:', error);
+    throw error;
+  }
+}
+
+export async function markAllNotificationsAsRead(userId: string): Promise<void> {
+  try {
+    await prisma.notification.updateMany({
+      where: { userId, read: false },
+      data: { read: true },
+    });
+  } catch (error) {
+    console.error('Error marking all notifications as read:', error);
+    throw error;
+  }
+}
+
+export async function notifyContributionApproval(contribution: Contribution): Promise<void> {
+  const message = `Your contribution "${contribution.description}" has been approved! You earned ${contribution.points} points.`;
+  await createNotification(
+    contribution.userId,
+    NotificationType.CONTRIBUTION_APPROVED,
+    message,
+    { contributionId: contribution.id }
+  );
+}
+
+export async function notifyNFTMinted(user: User, nft: NFT): Promise<void> {
+  const message = `Congratulations! You've minted a new NFT: ${nft.title}`;
+  await createNotification(user.id, NotificationType.NFT_MINTED, message, { nftId: nft.id });
+}
+
+export async function notifyLevelUp(user: User, newLevel: number): Promise<void> {
+  const message = `Congratulations! You've reached level ${newLevel}!`;
+  await createNotification(user.id, NotificationType.LEVEL_UP, message, { level: newLevel });
+}
+
+export async function notifyRankChange(user: User, oldRank: number, newRank: number): Promise<void> {
+  const message = `Your rank has changed from ${oldRank} to ${newRank}!`;
+  await createNotification(user.id, NotificationType.RANK_CHANGE, message, {
+    oldRank,
+    newRank,
+  });
+} 

src/lib/utils.ts

@@ -0,0 +1,134 @@
+import { ContributionType } from '../types/incentive';
+
+export function formatDate(date: Date): string {
+  return new Intl.DateTimeFormat('ko-KR', {
+    year: 'numeric',
+    month: 'long',
+    day: 'numeric',
+    hour: '2-digit',
+    minute: '2-digit',
+  }).format(date);
+}
+
+export function formatPoints(points: number): string {
+  return new Intl.NumberFormat('ko-KR').format(points);
+}
+
+export function getContributionTypeLabel(type: ContributionType): string {
+  const labels: Record<ContributionType, string> = {
+    [ContributionType.POST_CREATION]: '게시물 작성',
+    [ContributionType.COMMENT]: '댓글 작성',
+    [ContributionType.REVIEW]: '리뷰 작성',
+    [ContributionType.BUG_REPORT]: '버그 리포트',
+    [ContributionType.FEATURE_SUGGESTION]: '기능 제안',
+    [ContributionType.CODE_CONTRIBUTION]: '코드 기여',
+  };
+  return labels[type];
+}
+
+export function getLevelTitle(level: number): string {
+  if (level < 10) return '초보자';
+  if (level < 20) return '견습생';
+  if (level < 30) return '전문가';
+  if (level < 40) return '마스터';
+  if (level < 50) return '그랜드마스터';
+  return '레전드';
+}
+
+export function getRarityColor(rarity: string): string {
+  const colors: Record<string, string> = {
+    common: '#808080',
+    rare: '#4169E1',
+    epic: '#9932CC',
+    legendary: '#FFD700',
+  };
+  return colors[rarity] || '#808080';
+}
+
+export function calculateLevelProgress(points: number): { current: number; next: number; progress: number } {
+  const currentLevel = Math.floor(Math.sqrt(points / 100)) + 1;
+  const currentLevelPoints = Math.pow(currentLevel - 1, 2) * 100;
+  const nextLevelPoints = Math.pow(currentLevel, 2) * 100;
+  const progress = ((points - currentLevelPoints) / (nextLevelPoints - currentLevelPoints)) * 100;
+
+  return {
+    current: currentLevel,
+    next: currentLevel + 1,
+    progress,
+  };
+}
+
+export function generateRandomString(length: number): string {
+  const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+  let result = '';
+  for (let i = 0; i < length; i++) {
+    result += characters.charAt(Math.floor(Math.random() * characters.length));
+  }
+  return result;
+}
+
+export function truncateText(text: string, maxLength: number): string {
+  if (text.length <= maxLength) return text;
+  return text.slice(0, maxLength) + '...';
+}
+
+export function debounce<T extends (...args: any[]) => any>(
+  func: T,
+  wait: number
+): (...args: Parameters<T>) => void {
+  let timeout: NodeJS.Timeout;
+  return (...args: Parameters<T>) => {
+    clearTimeout(timeout);
+    timeout = setTimeout(() => func(...args), wait);
+  };
+}
+
+export function throttle<T extends (...args: any[]) => any>(
+  func: T,
+  limit: number
+): (...args: Parameters<T>) => void {
+  let inThrottle: boolean;
+  return (...args: Parameters<T>) => {
+    if (!inThrottle) {
+      func(...args);
+      inThrottle = true;
+      setTimeout(() => (inThrottle = false), limit);
+    }
+  };
+}
+
+export function formatFileSize(bytes: number): string {
+  if (bytes === 0) return '0 Bytes';
+  const k = 1024;
+  const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+}
+
+export function isValidUrl(url: string): boolean {
+  try {
+    new URL(url);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function getInitials(name: string): string {
+  return name
+    .split(' ')
+    .map(word => word[0])
+    .join('')
+    .toUpperCase();
+}
+
+export function groupBy<T>(array: T[], key: keyof T): Record<string, T[]> {
+  return array.reduce((result, item) => {
+    const groupKey = String(item[key]);
+    if (!result[groupKey]) {
+      result[groupKey] = [];
+    }
+    result[groupKey].push(item);
+    return result;
+  }, {} as Record<string, T[]>);
+} 

src/lib/validation.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { ContributionType } from '../types/incentive';
 
 export const PostSchema = z.object({
   title: z.string().min(1, '제목은 필수입니다.'),
@@ -29,4 +30,106 @@ export const FileDiffSchema = z.object({
 export type Post = z.infer<typeof PostSchema>;
 export type Commit = z.infer<typeof CommitSchema>;
 export type SearchQuery = z.infer<typeof SearchQuerySchema>;
-export type FileDiff = z.infer<typeof FileDiffSchema>; 
+export type FileDiff = z.infer<typeof FileDiffSchema>;
+
+export function validateEmail(email: string): boolean {
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  return emailRegex.test(email);
+}
+
+export function validatePassword(password: string): boolean {
+  // 최소 8자, 대문자, 소문자, 숫자, 특수문자 포함
+  const passwordRegex = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/;
+  return passwordRegex.test(password);
+}
+
+export function validateUsername(username: string): boolean {
+  // 영문자, 숫자, 언더스코어만 허용, 3-20자
+  const usernameRegex = /^[a-zA-Z0-9_]{3,20}$/;
+  return usernameRegex.test(username);
+}
+
+export function validateContributionType(type: string): boolean {
+  return Object.values(ContributionType).includes(type as ContributionType);
+}
+
+export function validatePoints(points: number): boolean {
+  return points > 0 && points <= 1000;
+}
+
+export function validateNFTMetadata(metadata: {
+  name: string;
+  description?: string;
+  image: string;
+  category: string;
+  rarity: string;
+}): boolean {
+  if (!metadata.name || metadata.name.length > 100) {
+    return false;
+  }
+
+  if (metadata.description && metadata.description.length > 1000) {
+    return false;
+  }
+
+  if (!metadata.image || !metadata.image.startsWith('https://')) {
+    return false;
+  }
+
+  if (!metadata.category || metadata.category.length > 50) {
+    return false;
+  }
+
+  if (!metadata.rarity || !['common', 'rare', 'epic', 'legendary'].includes(metadata.rarity)) {
+    return false;
+  }
+
+  return true;
+}
+
+export function validateAchievementRequirements(requirements: {
+  type: string;
+  value: number;
+}[]): boolean {
+  if (!Array.isArray(requirements) || requirements.length === 0) {
+    return false;
+  }
+
+  for (const req of requirements) {
+    if (!req.type || !req.value || req.value <= 0) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+export function validateNotificationMessage(message: string): boolean {
+  return message.length > 0 && message.length <= 500;
+}
+
+export function validateUserLevel(level: number): boolean {
+  return level > 0 && level <= 100;
+}
+
+export function validateUserPoints(points: number): boolean {
+  return points >= 0 && points <= 1000000;
+}
+
+export function validateUserRank(rank: number): boolean {
+  return rank > 0 && rank <= 1000;
+}
+
+export function validateUserStats(stats: {
+  totalPoints: number;
+  contributionCount: number;
+  nftCount: number;
+  rank: number;
+}): boolean {
+  return (
+    validateUserPoints(stats.totalPoints) &&
+    stats.contributionCount >= 0 &&
+    stats.nftCount >= 0 &&
+    validateUserRank(stats.rank)
+  );
+} 

src/types/incentive.ts

@@ -30,10 +30,10 @@ export interface NFT {
   title: string;
   description?: string;
   imageUrl: string;
-  owner: User;
-  createdAt: string;
   category: string;
   rarity: string;
+  owner: User;
+  createdAt: string;
 }
 
 export interface Contribution {
@@ -49,6 +49,6 @@ export interface Contribution {
 export interface LeaderboardEntry {
   user: User;
   totalPoints: number;
-  rank: number;
   contributionCount: number;
+  rank: number;
 }