room 도메인과 템플릿 계약 결합 정리

src/main/java/com/naminhyeok/fantazzk/room/application/CreateRoom.java

@@ -68,7 +68,7 @@ private Room newRoom(
         String hostActionToken,
         String hostNickname
     ) {
-        RoomTemplateSpec spec = RoomTemplateSpec.from(template);
+        RoomTemplateSpec spec = RoomTemplateSpecFactory.from(template);
         return Room.createFromTemplate(
             generateCode(),
             hostLeaderId,

src/main/java/com/naminhyeok/fantazzk/room/application/RoomTemplateSpecFactory.java

@@ -0,0 +1,70 @@
+package com.naminhyeok.fantazzk.room.application;
+
+import com.naminhyeok.fantazzk.room.domain.DraftOrderStrategy;
+import com.naminhyeok.fantazzk.room.domain.RoomMode;
+import com.naminhyeok.fantazzk.room.domain.RoomPlayerId;
+import com.naminhyeok.fantazzk.room.domain.RoomTemplateSpec;
+import com.naminhyeok.fantazzk.template.TemplateCatalog;
+import java.util.List;
+import java.util.Objects;
+
+final class RoomTemplateSpecFactory {
+    private RoomTemplateSpecFactory() {
+    }
+
+    static RoomTemplateSpec from(TemplateCatalog.TemplateBlueprint template) {
+        Objects.requireNonNull(template, "template must not be null");
+        List<RoomTemplateSpec.Player> players = template.players().stream()
+            .map(RoomTemplateSpecFactory::playerFrom)
+            .toList();
+        int requiredPlayerCount = template.teamCount() * (template.teamSize() - 1);
+        if (players.size() != requiredPlayerCount) {
+            throw new IllegalArgumentException("선수 수는 정확히 " + requiredPlayerCount + "명이어야 합니다");
+        }
+        return new RoomTemplateSpec(
+            template.gameType(),
+            roomModeFrom(template.mode()),
+            template.teamCount(),
+            template.teamSize(),
+            template.budget(),
+            requirePickBanTime(template.pickBanTime()),
+            template.minBidUnit(),
+            draftOrderStrategyFrom(template.draftOrderStrategy()),
+            players
+        );
+    }
+
+    private static RoomMode roomModeFrom(TemplateCatalog.Mode mode) {
+        return switch (Objects.requireNonNull(mode, "mode must not be null")) {
+            case AUCTION -> RoomMode.AUCTION;
+            case DRAFT -> RoomMode.DRAFT;
+        };
+    }
+
+    private static DraftOrderStrategy draftOrderStrategyFrom(TemplateCatalog.DraftOrderStrategy strategy) {
+        if (strategy == null) {
+            return null;
+        }
+        return switch (strategy) {
+            case SNAKE -> DraftOrderStrategy.SNAKE;
+            case FIXED -> DraftOrderStrategy.FIXED;
+        };
+    }
+
+    private static RoomTemplateSpec.Player playerFrom(TemplateCatalog.PlayerBlueprint player) {
+        Objects.requireNonNull(player, "player must not be null");
+        return new RoomTemplateSpec.Player(
+            new RoomPlayerId(player.playerIndex()),
+            player.name(),
+            player.position(),
+            player.playerIndex()
+        );
+    }
+
+    private static int requirePickBanTime(Integer pickBanTime) {
+        if (pickBanTime == null) {
+            throw new IllegalArgumentException("방 생성 명세에는 픽밴 시간이 필요합니다");
+        }
+        return pickBanTime;
+    }
+}

src/main/java/com/naminhyeok/fantazzk/room/domain/DraftOrderStrategy.java

@@ -1,18 +1,6 @@
 package com.naminhyeok.fantazzk.room.domain;
 
-import com.naminhyeok.fantazzk.template.TemplateCatalog;
-
 public enum DraftOrderStrategy {
     SNAKE,
-    FIXED;
-
-    public static DraftOrderStrategy from(TemplateCatalog.DraftOrderStrategy strategy) {
-        if (strategy == null) {
-            return null;
-        }
-        return switch (strategy) {
-            case SNAKE -> SNAKE;
-            case FIXED -> FIXED;
-        };
-    }
+    FIXED
 }

src/main/java/com/naminhyeok/fantazzk/room/domain/Room.java

@@ -216,26 +216,7 @@ public StartedGameSnapshot start(TeamLeaderId callerLeaderId, GameId gameId, Ins
         startedAt = Objects.requireNonNull(now, "now must not be null");
         status = RoomStatus.STARTED;
 
-        return new StartedGameSnapshot(
-            id,
-            code,
-            startedGameId,
-            startedAt,
-            gameType,
-            mode,
-            mode == RoomMode.AUCTION
-                ? GameRules.auction(teamCount, teamSize, budget, pickBanTime, minBidUnit)
-                : GameRules.draft(teamCount, teamSize, pickBanTime, draftOrderStrategy),
-            leaders.stream()
-                .map(leader -> mode == RoomMode.AUCTION
-                    ? GameParticipant.auction(leader.getId(), leader.getNickname(), leader.getRemainingBudget())
-                    : GameParticipant.draft(leader.getId(), leader.getNickname(), leader.getDraftPosition()))
-                .toList(),
-            players.stream()
-                .sorted(Comparator.comparingInt(RoomPlayer::getDisplayOrder))
-                .map(player -> new GamePlayer(player.getId(), player.getName(), player.getPosition(), player.getDisplayOrder()))
-                .toList()
-        );
+        return StartedGameSnapshotFactory.from(this);
     }
 
     private void validateDraftPositionChange(int draftPosition) {

src/main/java/com/naminhyeok/fantazzk/room/domain/RoomMode.java

@@ -1,16 +1,6 @@
 package com.naminhyeok.fantazzk.room.domain;
 
-import com.naminhyeok.fantazzk.template.TemplateCatalog;
-import java.util.Objects;
-
 public enum RoomMode {
     AUCTION,
-    DRAFT;
-
-    public static RoomMode from(TemplateCatalog.Mode mode) {
-        return switch (Objects.requireNonNull(mode, "mode must not be null")) {
-            case AUCTION -> AUCTION;
-            case DRAFT -> DRAFT;
-        };
-    }
+    DRAFT
 }

src/main/java/com/naminhyeok/fantazzk/room/domain/RoomTemplateSpec.java

@@ -1,6 +1,5 @@
 package com.naminhyeok.fantazzk.room.domain;
 
-import com.naminhyeok.fantazzk.template.TemplateCatalog;
 import java.util.List;
 import java.util.Objects;
 
@@ -53,42 +52,6 @@ public record RoomTemplateSpec(
         }
     }
 
-    public static RoomTemplateSpec from(TemplateCatalog.TemplateBlueprint template) {
-        Objects.requireNonNull(template, "template must not be null");
-        List<Player> players = template.players().stream().map(Player::from).toList();
-        int requiredPlayerCount = template.teamCount() * (template.teamSize() - 1);
-        if (players.size() != requiredPlayerCount) {
-            throw new IllegalArgumentException("선수 수는 정확히 " + requiredPlayerCount + "명이어야 합니다");
-        }
-        return new RoomTemplateSpec(
-            template.gameType(),
-            RoomMode.from(template.mode()),
-            template.teamCount(),
-            template.teamSize(),
-            template.budget(),
-            requirePickBanTime(template.pickBanTime()),
-            template.minBidUnit(),
-            DraftOrderStrategy.from(template.draftOrderStrategy()),
-            players
-        );
-    }
-
     public record Player(RoomPlayerId id, String name, String position, int displayOrder) {
-        public static Player from(TemplateCatalog.PlayerBlueprint player) {
-            Objects.requireNonNull(player, "player must not be null");
-            return new Player(
-                new RoomPlayerId(player.playerIndex()),
-                player.name(),
-                player.position(),
-                player.playerIndex()
-            );
-        }
-    }
-
-    private static int requirePickBanTime(Integer pickBanTime) {
-        if (pickBanTime == null) {
-            throw new IllegalArgumentException("방 생성 명세에는 픽밴 시간이 필요합니다");
-        }
-        return pickBanTime;
     }
 }

src/main/java/com/naminhyeok/fantazzk/room/domain/StartedGameSnapshotFactory.java

@@ -0,0 +1,47 @@
+package com.naminhyeok.fantazzk.room.domain;
+
+import java.util.Comparator;
+
+final class StartedGameSnapshotFactory {
+    private StartedGameSnapshotFactory() {
+    }
+
+    static StartedGameSnapshot from(Room room) {
+        return new StartedGameSnapshot(
+            room.getId(),
+            room.getCode(),
+            room.getStartedGameId(),
+            room.getStartedAt(),
+            room.getGameType(),
+            room.getMode(),
+            rulesOf(room),
+            room.getLeaders().stream()
+                .map(leader -> room.getMode() == RoomMode.AUCTION
+                    ? GameParticipant.auction(leader.getId(), leader.getNickname(), leader.getRemainingBudget())
+                    : GameParticipant.draft(leader.getId(), leader.getNickname(), leader.getDraftPosition()))
+                .toList(),
+            room.getPlayers().stream()
+                .sorted(Comparator.comparingInt(RoomPlayer::getDisplayOrder))
+                .map(player -> new GamePlayer(player.getId(), player.getName(), player.getPosition(), player.getDisplayOrder()))
+                .toList()
+        );
+    }
+
+    private static GameRules rulesOf(Room room) {
+        if (room.getMode() == RoomMode.AUCTION) {
+            return GameRules.auction(
+                room.getTeamCount(),
+                room.getTeamSize(),
+                room.getBudget(),
+                room.getPickBanTime(),
+                room.getMinBidUnit()
+            );
+        }
+        return GameRules.draft(
+            room.getTeamCount(),
+            room.getTeamSize(),
+            room.getPickBanTime(),
+            room.getDraftOrderStrategy()
+        );
+    }
+}

src/test/java/com/naminhyeok/fantazzk/architecture/RoomInternalPackageIsolationTest.java

@@ -43,6 +43,15 @@ class RoomInternalPackageIsolationTest {
                 "..room.infrastructure.."
             );
 
+    @ArchTest
+    static final ArchRule room_domain은_template_모듈에_의존하지_않는다 =
+        noClasses()
+            .that()
+            .resideInAnyPackage("..room.domain..")
+            .should()
+            .dependOnClassesThat()
+            .resideInAnyPackage("..template..");
+
     @ArchTest
     static final ArchRule room_query는_web이나_infrastructure에_의존하지_않는다 =
         noClasses()