Boundaries

// ❌ 정적 import - HMR 불가
import { UserModel } from "./user.model";

// ✅ 동적 import - HMR 가능
const { UserModel } = await import("./user.model");

// hmr-hook-register.ts
await hot.init({
  rootDirectory: process.env.API_ROOT_PATH,
  boundaries: [`./src/**/*.ts`],  // 모든 .ts 파일이 boundary
});

// server.ts
import { UserModel } from "./application/user/user.model";

// UserModel을 수정해도 반영되지 않음!
app.get("/users", async (req, res) => {
  const users = await UserModel.findMany();
  res.json(users);
});

// server.ts
app.get("/users", async (req, res) => {
  const { UserModel } = await import("./application/user/user.model");
  
  // UserModel을 수정하면 다음 요청 시 최신 코드가 로드됨!
  const users = await UserModel.findMany();
  res.json(users);
});

// syncer.ts - autoloadModels()
async autoloadModels() {
  for (const entity of entities) {
    const modelPath = `${entity.path}/${entity.id}.model`;
    
    // 동적 import로 로드 ✅
    const module = await import(modelPath);
    this.models[entity.id] = module[`${entity.id}Model`];
  }
}

// user.model.ts (boundary)
import { PostModel } from "./post.model";  // ✅ OK - 둘 다 boundary

export class UserModel extends BaseModel {
  async getPosts() {
    return PostModel.findMany({ where: { userId: this.id } });
  }
}

// server.ts (non-boundary)
import { UserModel } from "./user.model";  // ❌ 전체 재시작 필요

// server.ts (non-boundary) - 올바른 방법
async function loadModels() {
  const { UserModel } = await import("./user.model");  // ✅ OK
}

// Sonamu UI에서 User에 role 추가
role: EnumProp<"admin" | "user">

🔄 Invalidated:
- src/application/user/user.entity.ts
- src/application/user/user.model.ts

// user.model.ts
export class UserModel extends BaseModel {
  isAdmin(): boolean {
    return this.role === "admin";
  }
  
  canCreatePost(): boolean {
    return this.isAdmin() || this.role === "user";
  }
}

// post.api.ts
import { UserModel } from "../user/user.model";  // ✅ 둘 다 boundary

@api({ httpMethod: "POST" })
async create(body: PostForm) {
  const user = await UserModel.findById(body.userId);
  
  if (!user.canCreatePost()) {  // 👈 방금 추가한 메서드 바로 사용!
    throw new UnauthorizedError("You don't have permission to create posts");
  }
  
  return PostModel.save(body);
}

🔄 Invalidated:
- src/application/post/post.api.ts

✨ API re-registered: POST /api/post/create

// product.model.ts
export class ProductModel extends BaseModel {
  hasStock(quantity: number): boolean {
    return this.stock >= quantity;
  }
  
  async reserveStock(quantity: number) {
    if (!this.hasStock(quantity)) {
      throw new BadRequestError("Out of stock");
    }
    
    await this.update({ stock: this.stock - quantity });
  }
}

// order.model.ts
import { ProductModel } from "../product/product.model";  // ✅ OK
import { PaymentService } from "../payment/payment.service";

export class OrderModel extends BaseModel {
  static async createOrder(productId: number, quantity: number, userId: number) {
    const product = await ProductModel.findById(productId);
    
    // ProductModel.reserveStock()을 바로 사용 가능!
    await product.reserveStock(quantity);
    
    const order = await this.save({
      productId,
      quantity,
      userId,
      totalPrice: product.price * quantity,
      status: "pending",
    });
    
    return order;
  }
}

// order.api.ts
import { OrderModel } from "./order.model";

@api({ httpMethod: "POST" })
async create(body: { productId: number; quantity: number }) {
  const userId = getSonamuContext().userId!;
  
  // OrderModel.createOrder()를 바로 사용!
  const order = await OrderModel.createOrder(
    body.productId,
    body.quantity,
    userId
  );
  
  return order;
}

🔄 Invalidated:
- src/application/product/product.model.ts
- src/application/order/order.model.ts
- src/application/order/order.api.ts (with 3 APIs)

✨ API re-registered: POST /api/order/create

✅ All files are synced!

// notification.service.ts
export class NotificationService {
  private static timer: NodeJS.Timeout;
  
  static startPolling() {
    this.timer = setInterval(() => {
      console.log("Checking notifications...");
    }, 5000);
  }
}

// 재로드 전 타이머 정리
import.meta.hot?.dispose(() => {
  clearInterval(NotificationService.timer);
  console.log("Cleaned up notification polling timer");
});

// websocket-manager.ts
class WebSocketManager {
  private static connections = new Map<string, WebSocket>();
  
  static connect(url: string) {
    const ws = new WebSocket(url);
    this.connections.set(url, ws);
    return ws;
  }
}

import.meta.hot?.dispose(() => {
  // 모든 WebSocket 연결 종료
  for (const [url, ws] of WebSocketManager.connections) {
    ws.close();
    console.log(`Closed WebSocket: ${url}`);
  }
  WebSocketManager.connections.clear();
});

// config.ts
export const config = {
  database: {
    host: process.env.DB_HOST,
    port: parseInt(process.env.DB_PORT),
  },
  redis: {
    host: process.env.REDIS_HOST,
    port: parseInt(process.env.REDIS_PORT),
  },
};

// 이 파일이 변경되면 전체 재시작
import.meta.hot?.decline();

// database.config.ts
import { Sonamu } from "@sonamu-kit/sonamu";

export const dbPool = new Pool({
  host: Sonamu.config.database.host,
  port: Sonamu.config.database.port,
  user: Sonamu.config.database.user,
  password: Sonamu.config.database.password,
  database: Sonamu.config.database.database,
});

// DB 연결 설정 변경은 재시작 필요
import.meta.hot?.decline();

// cache-manager.ts
const cache = import.meta.hot?.boundary.userCache || new Map();

export class CacheManager {
  static set(key: string, value: any) {
    cache.set(key, value);
  }
  
  static get(key: string) {
    return cache.get(key);
  }
}

// 재로드 시에도 캐시 유지
import.meta.hot?.boundary.userCache = cache;

// rate-limiter.ts
const requestCounts = import.meta.hot?.boundary.requestCounts || new Map<string, number>();

export class RateLimiter {
  static check(userId: string): boolean {
    const count = requestCounts.get(userId) || 0;
    
    if (count >= 100) {
      return false;  // Rate limit exceeded
    }
    
    requestCounts.set(userId, count + 1);
    return true;
  }
}

// HMR 후에도 요청 카운트 유지
import.meta.hot?.boundary.requestCounts = requestCounts;

// src/types/import-meta.d.ts
interface ImportMeta {
  readonly hot?: {
    dispose(callback: () => Promise<void> | void): void;
    decline(): void;
    boundary: Record<string, any>;
  };
}

const dump = await hot.dump();
const userModel = dump.find(d => d.nodePath.includes("user.model.ts"));

console.log(`Boundary: ${userModel?.boundary}`);       // true
console.log(`Reloadable: ${userModel?.reloadable}`);   // true
console.log(`Children:`, userModel?.children);          // 의존하는 파일들

{
  "nodePath": "/project/src/application/user/user.model.ts",
  "boundary": true,
  "reloadable": true,
  "children": [
    "/project/src/application/user/user.api.ts",
    "/project/src/application/post/post.api.ts",
    "/project/src/application/admin/admin.api.ts"
  ]
}

const dump = await hot.dump();

for (const node of dump) {
  if (node.boundary) {
    console.log(`📦 ${node.nodePath}`);
    
    for (const child of node.children || []) {
      console.log(`   └─ ${child}`);
    }
  }
}

📦 /project/src/application/user/user.model.ts
   └─ /project/src/application/user/user.api.ts
   └─ /project/src/application/post/post.api.ts

📦 /project/src/application/post/post.model.ts
   └─ /project/src/application/post/post.api.ts

// hmr-hook-register.ts
await hot.init({
  rootDirectory: process.env.API_ROOT_PATH,
  boundaries: [
    // 자주 변경되는 파일만 Boundary로
    "./src/**/*.model.ts",
    "./src/**/*.api.ts",
    "./src/**/*.service.ts",
  ],
});

// ❌ 나쁜 예
import { UserModel } from "../user/user.model";
import { PostModel } from "../post/post.model";
import { CommentModel } from "../comment/comment.model";
// ... 많은 import

// ✅ 좋은 예
import { UserModel } from "../user/user.model";  // 실제로 사용하는 것만