Template Method 패턴

interface RawItem {
  title: string;
  link: string;
  pubDate: string;
  description: string;
}

abstract class BaseFeedParser {
  // 템플릿 메서드: 알고리즘의 골격을 정의
  async parse(xmlData: string, since: Date): Promise<ParsedItem[]> {
    const rawItems = this.extractRawItems(xmlData);       // 변하는 부분
    const filtered = this.filterByTime(rawItems, since);  // 고정된 부분
    const result = await this.convertToResult(filtered);   // 고정된 부분
    return result;
  }

  // 하위 클래스가 구현해야 하는 추상 메서드
  abstract canHandle(xmlData: string): boolean;
  protected abstract extractRawItems(xmlData: string): RawItem[];

  // 공통 로직: 시간 기준 필터링
  private filterByTime(items: RawItem[], since: Date): RawItem[] {
    return items.filter((item) => {
      const pubDate = new Date(item.pubDate);
      return pubDate >= since;
    });
  }

  // 공통 로직: 최종 변환
  private async convertToResult(items: RawItem[]): Promise<ParsedItem[]> {
    return Promise.all(
      items.map(async (item) => ({
        title: item.title,
        link: decodeURIComponent(item.link),
        publishedAt: new Date(item.pubDate),
        content: stripHtml(item.description),
      }))
    );
  }
}

import { XMLParser } from 'fast-xml-parser';

class Rss20Parser extends BaseFeedParser {
  private xmlParser = new XMLParser({
    ignoreAttributes: false,
    attributeNamePrefix: '@_',
  });

  canHandle(xmlData: string): boolean {
    const parsed = this.xmlParser.parse(xmlData);
    return !!parsed.rss?.channel?.item;
  }

  protected extractRawItems(xmlData: string): RawItem[] {
    const parsed = this.xmlParser.parse(xmlData);
    let items = parsed.rss.channel.item;

    // item이 하나뿐이면 배열이 아닌 객체로 파싱됨
    if (!Array.isArray(items)) {
      items = [items];
    }

    return items.map((feed: any) => ({
      title: feed.title,
      link: feed.link,
      pubDate: feed.pubDate,
      description: feed.description ?? '',
    }));
  }
}

class Atom10Parser extends BaseFeedParser {
  private xmlParser = new XMLParser({
    ignoreAttributes: false,
    attributeNamePrefix: '@_',
  });

  canHandle(xmlData: string): boolean {
    const parsed = this.xmlParser.parse(xmlData);
    return !!parsed.feed?.entry;
  }

  protected extractRawItems(xmlData: string): RawItem[] {
    const parsed = this.xmlParser.parse(xmlData);
    let entries = parsed.feed.entry;

    if (!Array.isArray(entries)) {
      entries = [entries];
    }

    return entries.map((entry: any) => ({
      title: entry.title,
      link: this.extractLink(entry.link),
      pubDate: entry.published || entry.updated,
      description: entry.summary || entry.content || '',
    }));
  }

  private extractLink(linkData: any): string {
    if (typeof linkData === 'string') return linkData;

    // Atom에서는 link가 배열일 수 있음 (alternate, self 등)
    if (Array.isArray(linkData)) {
      const alternate = linkData.find((l) => l['@_rel'] === 'alternate');
      return alternate?.['@_href'] || '';
    }

    return linkData['@_href'] || '';
  }
}

class FeedParserManager {
  private parsers: BaseFeedParser[];

  constructor(parsers: BaseFeedParser[]) {
    this.parsers = parsers;
  }

  async parse(xmlData: string, since: Date): Promise<ParsedItem[]> {
    // 데이터를 처리할 수 있는 파서를 자동으로 찾아 실행
    const parser = this.parsers.find((p) => p.canHandle(xmlData));

    if (!parser) {
      throw new Error('지원하지 않는 피드 포맷입니다');
    }

    return parser.parse(xmlData, since);
  }
}

// 사용
const manager = new FeedParserManager([
  new Rss20Parser(),
  new Atom10Parser(),
]);

const items = await manager.parse(xmlData, new Date('2025-07-01'));

abstract class Sorter {
  sort(data: number[]): number[] {
    const prepared = this.prepare(data);  // 고정
    const sorted = this.doSort(prepared); // 변하는 부분
    return this.finalize(sorted);         // 고정
  }

  protected abstract doSort(data: number[]): number[];

  private prepare(data: number[]): number[] {
    return [...data]; // 원본 보호
  }
  private finalize(data: number[]): number[] {
    return data;
  }
}

class QuickSorter extends Sorter {
  protected doSort(data: number[]): number[] {
    // 퀵소트 구현
    return data.sort((a, b) => a - b);
  }
}

interface SortStrategy {
  sort(data: number[]): number[];
}

class Sorter {
  constructor(private strategy: SortStrategy) {}

  sort(data: number[]): number[] {
    const prepared = [...data];
    return this.strategy.sort(prepared);
  }

  // 런타임에 전략 교체 가능
  setStrategy(strategy: SortStrategy) {
    this.strategy = strategy;
  }
}

abstract class BaseProcessor {
  // public: 외부에서 호출하는 유일한 진입점
  public process(input: string): Result {
    const validated = this.validate(input);
    const transformed = this.transform(validated);
    return this.format(transformed);
  }

  // protected abstract: 하위 클래스가 반드시 구현
  protected abstract transform(data: ValidData): TransformedData;

  // protected: 하위 클래스가 선택적으로 오버라이드 가능 (hook)
  protected validate(input: string): ValidData {
    // 기본 유효성 검사
    if (!input) throw new Error('입력값이 비어있습니다');
    return { raw: input };
  }

  // private: 하위 클래스가 절대 변경 불가
  private format(data: TransformedData): Result {
    return { data, timestamp: new Date() };
  }
}