TypeScript로 다시 읽는 GoF 디자인 패턴 — 1편: 들어가며와 생성 패턴

// 요청마다 풀이 새로 만들어진다 — 커넥션이 금방 고갈된다
export async function getUser(id: string) {
  const pool = new Pool({ connectionString: process.env.DATABASE_URL });
  return pool.query("SELECT * FROM users WHERE id = $1", [id]);
}

export class Database {
  static #instance: Database | null = null;
  readonly pool: Pool;
 
  private constructor() {
    this.pool = new Pool({ connectionString: process.env.DATABASE_URL });
  }
 
  static getInstance(): Database {
    if (!Database.#instance) {
      Database.#instance = new Database();
    }
    return Database.#instance;
  }
}
 
const db = Database.getInstance();

// db.ts
export const pool = new Pool({ connectionString: process.env.DATABASE_URL });

const globalForDb = globalThis as unknown as { pool?: Pool };
 
export const pool =
  globalForDb.pool ?? new Pool({ connectionString: process.env.DATABASE_URL });
 
if (process.env.NODE_ENV !== "production") {
  globalForDb.pool = pool;
}

// 의존성을 인자로 받는다 — 테스트에서 가짜 pool을 넣을 수 있다
export function createUserRepository(pool: Pool) {
  return {
    findById: (id: string) => pool.query("SELECT * FROM users WHERE id = $1", [id]),
  };
}

export async function notify(channel: string, to: string, message: string) {
  if (channel === "email") {
    await new EmailSender(smtpConfig).send(to, message);
  } else if (channel === "sms") {
    await new SmsSender(smsApiKey).send(to, message);
  } else if (channel === "slack") {
    await new SlackSender(webhookUrl).send(to, message);
  }
}

interface Sender {
  send(to: string, message: string): Promise<void>;
}
 
abstract class Notifier {
  // 팩토리 메서드 — 하위 클래스가 구현한다
  protected abstract createSender(): Sender;
 
  async notify(to: string, message: string) {
    const sender = this.createSender();
    await sender.send(to, this.format(message));
  }
 
  protected format(message: string) {
    return `[알림] ${message}`;
  }
}
 
class EmailNotifier extends Notifier {
  protected createSender() {
    return new EmailSender(smtpConfig);
  }
}
 
class SlackNotifier extends Notifier {
  protected createSender() {
    return new SlackSender(webhookUrl);
  }
}

type SenderFactory = () => Sender;
 
const senderFactories = {
  email: () => new EmailSender(smtpConfig),
  sms: () => new SmsSender(smsApiKey),
  slack: () => new SlackSender(webhookUrl),
} satisfies Record<string, SenderFactory>;
 
export function createSender(channel: keyof typeof senderFactories): Sender {
  return senderFactories[channel]();
}

// 조합을 각자 결정하면 잘못된 짝이 섞이기 쉽다
const storage = isProd ? new S3Storage() : new DiskStorage();
const queue = isProd ? new SqsQueue() : new InMemoryQueue();
const cache = process.env.USE_REDIS ? new RedisCache() : new MemoryCache(); // 기준이 또 다르다

interface FileStorage {
  save(key: string, body: Buffer): Promise<void>;
}
 
interface JobQueue {
  enqueue(job: Job): Promise<void>;
}
 
// 추상 팩토리 — 제품군을 한 번에 만든다
interface InfraFactory {
  createStorage(): FileStorage;
  createQueue(): JobQueue;
}
 
class CloudInfraFactory implements InfraFactory {
  createStorage() { return new S3Storage(process.env.BUCKET!); }
  createQueue() { return new SqsQueue(process.env.QUEUE_URL!); }
}
 
class LocalInfraFactory implements InfraFactory {
  createStorage() { return new DiskStorage("./.data"); }
  createQueue() { return new InMemoryQueue(); }
}
 
// 환경 판단은 딱 한 곳에서
export function createInfraFactory(): InfraFactory {
  return process.env.NODE_ENV === "production"
    ? new CloudInfraFactory()
    : new LocalInfraFactory();
}
 
// 사용하는 쪽은 제품군이 무엇인지 모른다
const infra = createInfraFactory();
const storage = infra.createStorage();
const queue = infra.createQueue();

const localInfra: InfraFactory = {
  createStorage: () => new DiskStorage("./.data"),
  createQueue: () => new InMemoryQueue(),
};

const query = new SearchQuery("users", ["id", "name"], "age > 20", "name", "ASC", 20, 40, true, false);
// 여덟 번째 true는 무슨 뜻인가? 아홉 번째 false는?

type Order = "ASC" | "DESC";
 
class SearchQuery {
  constructor(
    readonly table: string,
    readonly columns: string[],
    readonly conditions: string[],
    readonly orderBy: { column: string; order: Order } | null,
    readonly limit: number | null,
    readonly offset: number | null,
  ) {}
}
 
class SearchQueryBuilder {
  #columns: string[] = ["*"];
  #conditions: string[] = [];
  #orderBy: { column: string; order: Order } | null = null;
  #limit: number | null = null;
  #offset: number | null = null;
 
  constructor(private readonly table: string) {}
 
  select(...columns: string[]) {
    this.#columns = columns;
    return this;
  }
 
  where(condition: string) {
    this.#conditions.push(condition);
    return this;
  }
 
  orderBy(column: string, order: Order = "ASC") {
    this.#orderBy = { column, order };
    return this;
  }
 
  paginate(page: number, size: number) {
    if (page < 1 || size < 1) throw new Error("page와 size는 1 이상이어야 합니다");
    this.#limit = size;
    this.#offset = (page - 1) * size;
    return this;
  }
 
  build() {
    return new SearchQuery(
      this.table, this.#columns, this.#conditions,
      this.#orderBy, this.#limit, this.#offset,
    );
  }
}
 
const query = new SearchQueryBuilder("users")
  .select("id", "name")
  .where("age > 20")
  .orderBy("name")
  .paginate(3, 20)
  .build();

function createSearchQuery(options: {
  table: string;
  columns?: string[];
  limit?: number;
}) { /* ... */ }
 
createSearchQuery({ table: "users", limit: 20 });

interface Cloneable<T> {
  clone(): T;
}
 
class ChartConfig implements Cloneable<ChartConfig> {
  constructor(
    public title: string,
    public series: { name: string; color: string }[],
    public axis: { min: number; max: number },
  ) {}
 
  clone(): ChartConfig {
    return new ChartConfig(
      this.title,
      this.series.map((s) => ({ ...s })), // 중첩 배열은 깊게 복사
      { ...this.axis },
    );
  }
}
 
const original = new ChartConfig("매출", [{ name: "2026", color: "#0a0" }], { min: 0, max: 100 });
const copy = original.clone();
copy.title = "매출 (사본)";
copy.series[0].color = "#a00"; // 원본에는 영향 없음

const plainConfig = { title: "매출", series: [{ name: "2026", color: "#0a0" }] };
const deepCopy = structuredClone(plainConfig);