기술 부채의 재정의

// 전통적으로 "좋은 코드"로 여겨지던 극도로 DRY한 제네릭 유틸
type DeepPartial<T> = T extends object
  ? { [P in keyof T]?: DeepPartial<T[P]> }
  : T;

type PathKeys<T> = T extends object
  ? { [K in keyof T]: K extends string
    ? T[K] extends object
      ? K | `${K}.${PathKeys<T[K]>}`
      : K
    : never
  }[keyof T]
  : never;

function deepUpdate<T extends object>(
  obj: T,
  path: PathKeys<T>,
  value: unknown
): T {
  // 12줄의 재귀 로직
  const keys = (path as string).split(".");
  // ...복잡한 구현
}

// 대안 - 명시적이고 구체적인 함수
function updateUserProfile(
  user: User,
  field: "name" | "email" | "phone",
  value: string
): User {
  return { ...user, [field]: value };
}

function updateOrderStatus(
  order: Order,
  status: "pending" | "confirmed" | "shipped"
): Order {
  return { ...order, status, updatedAt: new Date() };
}

// 데코레이터 체이닝 방식
@Controller("/users")
@UseGuards(AuthGuard)
@UseInterceptors(LoggingInterceptor, CacheInterceptor)
@ApiTags("Users")
class UserController {
  @Get("/:id")
  @Cacheable(300)
  @RateLimit(100)
  @Validate(GetUserSchema)
  async getUser(@Param("id") id: string) {
    return this.userService.findById(id);
  }
}

// 명시적 미들웨어 체이닝 방식
export async function GET(
  request: Request,
  context: RouteContext
) {
  // 1. 인증 확인
  const session = await getServerSession();
  if (!session) return unauthorized();

  // 2. Rate limit 확인
  const allowed = await checkRateLimit(session.userId, 100);
  if (!allowed) return tooManyRequests();

  // 3. 입력 검증
  const { id } = validateParams(context.params, GetUserSchema);

  // 4. 캐시 확인
  const cached = await cache.get(`user:${id}`);
  if (cached) return NextResponse.json(cached);

  // 5. 비즈니스 로직
  const user = await userService.findById(id);

  // 6. 캐시 저장
  await cache.set(`user:${id}`, user, 300);

  return NextResponse.json(user);
}

// 전통적 DRY: 공통 헬퍼로 추출
// utils/formatDate.ts에 12가지 날짜 포맷 함수

export function formatDate(date: Date, format: string): string {
  // 200줄의 범용 포맷 함수
}

export function formatRelative(date: Date): string {
  return formatDate(date, "relative");
}

export function formatISO(date: Date): string {
  return formatDate(date, "iso");
}

// ... 9개 더

// 각 컴포넌트에서 인라인으로 작성한 경우

// OrderList.tsx
function formatOrderDate(date: Date): string {
  return dayjs(date).tz("Asia/Seoul").format("YYYY.MM.DD");
}

// UserProfile.tsx
function formatJoinDate(date: Date): string {
  return dayjs(date).tz("Asia/Seoul").format("YYYY년 M월 D일");
}

// 각 함수는 독립적 - AI가 컨텍스트 없이 바로 수정 가능
// 한 곳의 변경이 12곳에 전파되지 않음

// 복잡한 타입 추론 체인
const result = data
  .filter(Boolean)
  .map(transform)
  .reduce(accumulate, initial);
// result의 타입을 AI가 추론하려면 3개 함수를 모두 분석해야 함

// 명시적 타입 명시
const activeUsers: ActiveUser[] = data
  .filter((user): user is ActiveUser => user !== null)
  .map((user): UserSummary => ({
    id: user.id,
    name: user.name,
  }));

// 파일 1개를 이해하려면 5개 파일이 필요한 구조
// OrderService.ts
import { BaseService } from "./base";         // 추상 클래스
import { mixinCacheable } from "./mixins";     // 믹스인
import { OrderDecorators } from "./decorators"; // 데코레이터
import { ORDER_CONFIG } from "./config";        // 설정
import { OrderTypes } from "./types";           // 타입

// 파일 하나로 이해 가능한 구조
// order-service.ts
interface OrderInput { ... }
interface OrderResult { ... }
const CACHE_TTL = 300;

export async function createOrder(input: OrderInput): Promise<OrderResult> {
  // 모든 로직이 이 파일 안에서 완결
}

// AI가 맥락 없이 이해하기 어려운 이름
const result = process(data);
const output = handle(input);
const value = compute(items);

// AI가 이름만으로 동작을 추론할 수 있는 이름
const validatedOrder = validateAndNormalizeOrder(rawOrderData);
const monthlyRevenue = calculateMonthlyRevenue(transactions);
const eligibleUsers = filterEligibleUsersForPromotion(allUsers);

// 전통적 "좋은 설계" - 하지만 AI가 이해하기 어려움
abstract class BaseRepository<T> {
  abstract tableName: string;
  async findById(id: string): Promise<T | null> { /* ... */ }
  async findAll(): Promise<T[]> { /* ... */ }
  async create(data: Partial<T>): Promise<T> { /* ... */ }
}

class CacheableRepository<T> extends BaseRepository<T> {
  // BaseRepository를 읽어야 이해 가능
  async findById(id: string): Promise<T | null> {
    const cached = await this.cache.get(id);
    if (cached) return cached;
    return super.findById(id);
  }
}

class UserRepository extends CacheableRepository<User> {
  // BaseRepository + CacheableRepository를 읽어야 이해 가능
  tableName = "users";
}

// 이 파일만 읽으면 모든 동작을 이해할 수 있는 구조
interface UserRepository {
  findById(id: string): Promise<User | null>;
  findAll(): Promise<User[]>;
  create(data: CreateUserInput): Promise<User>;
}

export function createUserRepository(
  db: PrismaClient,
  cache: CacheClient
): UserRepository {
  return {
    async findById(id) {
      const cached = await cache.get<User>(`user:${id}`);
      if (cached) return cached;

      const user = await db.user.findUnique({ where: { id } });
      if (user) await cache.set(`user:${id}`, user, 300);
      return user;
    },

    async findAll() {
      return db.user.findMany({ orderBy: { createdAt: "desc" } });
    },

    async create(data) {
      return db.user.create({ data });
    },
  };
}