Next.js 미들웨어의 복잡성을 해결하는 파이프라인 라이브러리 개발기

// middleware.ts (초기 버전)
export function middleware(request: NextRequest) {
  const token = request.cookies.get('auth-token');

  if (!token) {
    return NextResponse.redirect(new URL('/login', request.url));
  }

  return NextResponse.next();
}

export function middleware(request: NextRequest) {
  // 1. 에러 추적 설정
  const requestId = generateRequestId();

  // 2. CORS 처리
  if (request.method === 'OPTIONS') {
    return new Response(null, {
      status: 200,
      headers: corsHeaders
    });
  }

  // 3. Rate limiting 체크
  const ip = getClientIP(request);
  if (await isRateLimited(ip)) {
    return NextResponse.json({ error: 'Too many requests' }, { status: 429 });
  }

  // 4. 유지보수 모드 체크
  if (await isMaintenanceMode()) {
    return NextResponse.redirect(new URL('/maintenance', request.url));
  }

  // 5. 토큰 영속화
  const token = request.headers.get('authorization') || request.cookies.get('auth-token');
  if (token) {
    // 토큰 저장 로직...
  }

  // 6. 인증 체크
  if (protectedPaths.some(path => request.nextUrl.pathname.startsWith(path))) {
    if (!token || !await validateToken(token)) {
      return NextResponse.redirect(new URL('/login', request.url));
    }
  }

  // 7. 응답 헤더 설정
  const response = NextResponse.next();
  response.headers.set('X-Request-ID', requestId);
  response.headers.set('X-Frame-Options', 'DENY');

  return response;
}

app.use(cors());
app.use(rateLimiter);
app.use(authenticate);
app.use(authorize);

function authMiddleware(req, res, next) {
  if (!req.headers.authorization) {
    return res.status(401).json({ error: 'Unauthorized' });
  }

  // 인증 성공 시 다음 미들웨어로
  next();
}

async function handleCORS(request: NextRequest) {
  if (request.method === 'OPTIONS') {
    return new Response(null, { status: 200, headers: corsHeaders });
  }
  return null;
}

async function handleAuth(request: NextRequest) {
  const token = request.cookies.get('auth-token');
  if (!token) {
    return NextResponse.redirect(new URL('/login', request.url));
  }
  return null;
}

export async function middleware(request: NextRequest) {
  const corsResponse = await handleCORS(request);
  if (corsResponse) return corsResponse;

  const authResponse = await handleAuth(request);
  if (authResponse) return authResponse;

  return NextResponse.next();
}

interface BaseRequest {
  url: string;
  method: string;
  headers: Record<string, string | string[]>;
}

interface FrameworkAdapter<TRawRequest, TRawResponse, TRequest, TResponse> {
  createRequest(rawRequest: TRawRequest): TRequest;
  createResponse(response: TResponse): TRawResponse;
  createNextResponse(): TResponse;
  createErrorResponse(error: Error, statusCode?: number): TResponse;
}

try {
  const response = await middleware.handler(request, next);
  return response;
} catch (error) {
  // 에러를 리포팅하되 서비스는 계속 진행
  await this.handleError(error, request);
  return next();
}

private createChain(middlewares: Middleware[]): (request: TRequest) => Promise<TResponse> {
  return async (request: TRequest) => {
    let index = 0;

    const next: NextFunction<TResponse> = async () => {
      if (index >= middlewares.length) {
        return this.adapter.createNextResponse();
      }

      const current = middlewares[index++];

      if (this.shouldExecute(current, request)) {
        return current.handler(request, next);
      }

      return next();
    };

    return next();
  };
}

class Context<T = Record<string, any>> {
  private data: T;

  set<K extends keyof T>(key: K, value: T[K]): void {
    this.data[key] = value;
  }

  get<K extends keyof T>(key: K): T[K] | undefined {
    return this.data[key];
  }
}

// 인증 미들웨어
const authMiddleware = createMiddleware({
  name: 'auth',
  handler: async (request, next) => {
    const user = await validateToken(request.headers.authorization);
    request.context.set('user', user);
    return next();
  }
});

// 권한 확인 미들웨어
const authzMiddleware = createMiddleware({
  name: 'authorization',
  handler: async (request, next) => {
    const user = request.context.get('user');
    if (!user.roles.includes('admin')) {
      return { status: 403, body: 'Forbidden' };
    }
    return next();
  }
});

pipeline
  .use(authMiddleware)        // 순차 실행
  .useParallel([              // 병렬 실행
    loggingMiddleware,
    analyticsMiddleware,
    metricsMiddleware
  ])
  .use(businessLogicMiddleware);

interface MiddlewarePlugin {
  name: string;
  version: string;

  onInit?(): void | Promise<void>;
  beforeMiddleware?(middleware: Middleware, request: BaseRequest): void | Promise<void>;
  afterMiddleware?(middleware: Middleware, request: BaseRequest, response: BaseResponse): void | Promise<void>;
  onError?(error: Error, middleware: Middleware, request: BaseRequest): void | Promise<void>;
}

const pipeline = new MiddlewarePipeline({
  adapter: createNextJsAdapter(),
  plugins: [
    createErrorReporter({
      service: 'sentry',
      enabled: process.env.NODE_ENV === 'production'
    })
  ]
});

// middleware.ts (500줄)
export function middleware(request: NextRequest) {
  // 1. 에러 추적
  // 2. CORS 처리
  // 3. Rate limiting
  // 4. 유지보수 모드
  // 5. 토큰 영속화
  // 6. 인증/인가
  // 7. 로깅
  // ... 500줄의 혼재된 로직
}

// middleware.ts
export const middleware = createNextJsMiddleware((pipeline) => {
  pipeline
    .use(requestIdMiddleware)
    .use(corsMiddleware)
    .use(tokenPersistenceMiddleware)
    .use(authMiddleware)
    .use(authorizationMiddleware)
    .useIf(
      process.env.NODE_ENV === 'production',
      rateLimitMiddleware
    )
    .useParallel([
      performanceMiddleware,
      analyticsMiddleware
    ]);
});

// middlewares/auth.ts
export const authMiddleware = createMiddleware({
  name: 'authentication',
  matcher: ['/api/*', '/dashboard/*'],
  handler: async (request, next) => {
    // 명확한 인증 로직만
  }
});