Design Principles & Patterns

// Hai actor khác nhau: finance vs. ops
class Invoice {
  total(): Money { /* finance rules */ }
  toPdf(): Buffer { /* layout team */ }   // tách ra InvoicePdfRenderer
}

type Fetcher = (url: string) => Promise<Response>;
const withRetry = (f: Fetcher, n = 3): Fetcher => async (u) => {
  for (let i = 0; ; i++) {
    try { return await f(u); } catch (e) { if (i >= n - 1) throw e; }
  }
};
const withLog = (f: Fetcher): Fetcher => async (u) => { console.time(u); try { return await f(u); } finally { console.timeEnd(u); } };
const http = withLog(withRetry(fetch)); // ghép tuỳ ý, không cần subclass

interface Clock { now(): Date }
interface OrderRepo { save(o: Order): Promise<void> }

class PlaceOrder {
  constructor(private repo: OrderRepo, private clock: Clock) {}
  async run(cmd: PlaceOrderCmd) {
    const order = Order.create(cmd, this.clock.now());
    await this.repo.save(order);
  }
}

// composition root
const useCase = new PlaceOrder(new SqlOrderRepo(pool), { now: () => new Date() });
// test
const t = new PlaceOrder(new InMemoryOrderRepo(), { now: () => new Date('2026-01-01') });

type ShippingFee = (o: { weightKg: number; subtotal: number }) => number;

const strategies: Record<'standard' | 'express' | 'free', ShippingFee> = {
  standard: (o) => 20_000 + o.weightKg * 5_000,
  express: (o) => 50_000 + o.weightKg * 8_000,
  free: () => 0,
};

const fee = strategies[order.shippingMethod](order);

interface PaymentGateway { charge(amount: Money, token: string): Promise<ChargeResult> }

class StripeAdapter implements PaymentGateway {
  constructor(private stripe: Stripe) {}
  async charge(amount: Money, token: string) {
    const pi = await this.stripe.paymentIntents.create({ amount: amount.minor, currency: amount.currency, payment_method: token, confirm: true });
    return { id: pi.id, status: pi.status === 'succeeded' ? 'paid' : 'pending' } as const;
  }
}

interface DiscountRule { applies(c: Cart): boolean; amount(c: Cart): number }
class Pricing {
  constructor(private rules: DiscountRule[]) {}
  discount(c: Cart) { return this.rules.filter(r => r.applies(c)).reduce((s, r) => s + r.amount(c), 0); }
}
// thêm rule mới = thêm class/object mới, Pricing không đổi

class FileStorage { async write(path: string, data: Buffer) { /* ... */ } }
class ReadOnlyStorage extends FileStorage {
  async write(): Promise<void> { throw new Error('read-only'); } // compile OK, LSP broken
}

// Trước
interface OrderRepository { findById; findByUser; search; save; delete; archive; exportCsv; /* ... */ }
// Sau
interface OrderReader { findById(id: OrderId): Promise<Order | null> }
interface OrderWriter { save(o: Order): Promise<void> }
class CancelOrder { constructor(private orders: OrderReader & OrderWriter) {} }
class SqlOrderRepository implements OrderReader, OrderWriter { /* ... */ }

type Channel = 'email' | 'sms' | 'push';
interface Notifier { send(to: string, msg: string): Promise<void> }
const createNotifier = (c: Channel, deps: Deps): Notifier => {
  switch (c) {
    case 'email': return new SesNotifier(deps.ses);
    case 'sms': return new TwilioNotifier(deps.twilio);
    case 'push': return new FcmNotifier(deps.fcm);
    default: { const _exhaustive: never = c; throw new Error(_exhaustive); }
  }
};

class OrderBuilder {
  private o: Partial<Order> = { status: 'draft', lines: [] };
  withLine(sku: string, qty: number) { this.o.lines!.push({ sku, qty }); return this; }
  paid() { this.o.status = 'paid'; return this; }
  build(): Order {
    if (!this.o.lines!.length) throw new Error('order needs at least one line');
    return Object.freeze({ id: randomUUID(), ...this.o }) as Order;
  }
}
const order = new OrderBuilder().withLine('SKU-1', 2).paid().build();

const lazy = <T extends object>(factory: () => T): T => {
  let inst: T | undefined;
  return new Proxy({} as T, { get: (_t, k) => {
    const i = (inst ??= factory());
    const v = Reflect.get(i, k, i);
    return typeof v === 'function' ? v.bind(i) : v; // giữ `this` = instance thật (#private OK)
  } });
};
const s3 = lazy(() => new S3Client({ region: 'ap-southeast-1' })); // chỉ khởi tạo khi dùng lần đầu

interface Command<T = unknown> { type: string; payload: T; idempotencyKey: string }
const handlers: Record<string, (c: Command<any>) => Promise<void>> = {
  'invoice.send': async (c) => sendInvoice(c.payload.orderId),
};
async function dispatch(c: Command) {
  if (await processed.has(c.idempotencyKey)) return;
  await handlers[c.type](c);
  await processed.add(c.idempotencyKey);
}

abstract class Importer<Row> {
  async run(file: Buffer) {
    const rows = this.parse(file);
    const valid = rows.filter((r) => this.validate(r));
    await this.save(valid);
  }
  protected abstract parse(f: Buffer): Row[];
  protected abstract validate(r: Row): boolean;
  protected abstract save(rows: Row[]): Promise<void>;
}

await prisma.$transaction(async (tx) => {
  const order = await tx.order.update({ where: { id }, data: { status: 'PAID' } });
  await tx.outbox.create({ data: { type: 'order.paid', payload: { orderId: order.id } } });
}); // commit hoặc rollback cả hai

// cart.service.ts
class CartService {
  private currentUserId?: string;
  setUser(id: string) { this.currentUserId = id; }
  async getCart() {
    await delay(5); // simulate DB
    return db.cart.findFirst({ where: { userId: this.currentUserId } });
  }
}
export const cartService = new CartService();

// route
app.get('/cart', async (req, res) => {
  cartService.setUser(req.user.id);
  res.json(await cartService.getCart());
});

const priceEvents = new EventEmitter();

app.get('/prices/stream', (req, res) => {
  res.setHeader('Content-Type', 'text/event-stream');
  priceEvents.on('price', (p) => res.write(`data: ${JSON.stringify(p)}\n\n`));
});

interface PaymentGateway {
  charge(amount: number): Promise<string>;
  refund(chargeId: string, amount: number): Promise<void>;
}
class CodGateway implements PaymentGateway { // Cash on delivery
  async charge() { return 'cod-' + Date.now(); }
  async refund() { throw new Error('COD cannot be refunded online'); }
}
// refund job, written against the interface
for (const o of cancelledOrders) await gateways[o.method].refund(o.chargeId, o.total);

class Order {
  private constructor(private status: 'pending' | 'paid' | 'cancelled', private paidAt?: Date) {}
  pay(at: Date) {
    if (this.status !== 'pending') throw new DomainError('ORDER_NOT_PAYABLE');
    this.status = 'paid'; this.paidAt = at;
  }
}

class Money {
  private constructor(readonly minor: bigint, readonly currency: 'VND' | 'USD') {}
  static of(minor: bigint, c: 'VND' | 'USD') { return new Money(minor, c); }
  add(o: Money) { if (o.currency !== this.currency) throw new Error('CURRENCY_MISMATCH'); return new Money(this.minor + o.minor, this.currency); }
  equals(o: Money) { return this.minor === o.minor && this.currency === o.currency; }
}

type OrderEvent =
  | { type: 'OrderPlaced'; v: 1; orderId: string; total: number }
  | { type: 'OrderPaid'; v: 1; orderId: string; paidAt: string };
const apply = (s: OrderState, e: OrderEvent): OrderState =>
  e.type === 'OrderPlaced' ? { ...s, status: 'pending', total: e.total }
  : e.type === 'OrderPaid' ? { ...s, status: 'paid' } : s;
const state = events.reduce(apply, initial);

// order.service.ts
import { userService, UserService } from './user.service';
export class OrderService {
  constructor(private users: UserService) {}
  owner(id: string) { return this.users.find(id); }
}
export const orderService = new OrderService(userService); // reads the binding at load time

// user.service.ts
import { orderService } from './order.service';
export class UserService {
  find(id: string) { /* ... */ }
  orders(id: string) { return orderService.owner(id); }
}
export const userService = new UserService();

// main.ts (CommonJS build)
import { userService } from './user.service'; // user.service loads first

class CachedProductRepo implements ProductRepo {
  constructor(private inner: ProductRepo, private cache: Redis) {}
  async findBySku(sku: string, ctx: { tenantId: string }) {
    const key = `product:${sku}`;
    const hit = await this.cache.get(key);
    if (hit) return JSON.parse(hit);
    const p = await this.inner.findBySku(sku, ctx);
    await this.cache.set(key, JSON.stringify(p), 'EX', 300);
    return p;
  }
}

await uow.run(async (tx) => {
  const order = await tx.orders.byId(id);
  order.pay(clock.now());                       // records OrderPaid
  await tx.orders.save(order);
  await tx.outbox.addAll(order.pullEvents());   // same transaction
});

src/orders/
  domain/order.ts, money.ts, events.ts
  application/place-order.ts, ports.ts
  adapters/http/orders.controller.ts
  adapters/sql/sql-order-repository.ts
src/main.ts   // wiring

type Result<T, E extends string> = { ok: true; value: T } | { ok: false; error: E };
function reserve(stock: number, qty: number): Result<number, 'INSUFFICIENT_STOCK'> {
  return qty <= stock ? { ok: true, value: stock - qty } : { ok: false, error: 'INSUFFICIENT_STOCK' };
}