1// 예시: In() 연산자를 활용한 배치 쿼리로 N+1 문제 해결
2async findDirectRelations(nodeIdList: number[]): Promise<NodeRelation[]> {
3    // N개 노드의 관계를 1번의 쿼리로 조회 (N+1 → 1)
4    return await this.relationRepository.find({
5        where: [
6            { depth: 1, ancestor: In(nodeIdList) },
7            { depth: 1, descendant: In(nodeIdList) },
8        ],
9        relations: ['ancestor', 'descendant'],
10    });
11}
12
13// 예시: 조회 결과를 Map으로 변환하여 O(1) 검색 제공
14async getMetricsWithRate(metricList: Metric[]): Promise<Metric[]> {
15    const idList = metricList.map(m => m.id);
16
17    // 모든 메트릭의 월별 데이터를 한 번에 조회
18    const monthlyData = await this.monthlyRepository.find({
19        where: { metricId: In(idList), period: lastMonth }
20    });
21
22    // Map으로 변환 → O(1) 검색
23    const dataMap = new Map(
24        monthlyData.map(item => [item.metricId, item])
25    );
26
27    // 기존 리스트에 달성률 추가
28    return metricList.map(metric => ({
29        ...metric,
30        rate: calculateRate(dataMap.get(metric.id))
31    }));
32}

1// 예시: 리프 노드에서 루트로 정보 전파
2private propagateInfoUpwards(
3    nodeMap: Map<number, TreeNode>,
4    parentMap: Map<number, number>,  // childId → parentId
5    leafNodeIds: Set<number>,
6): void {
7    const propagateToAncestors = (nodeId: number): void => {
8        let currentId = nodeId;
9
10        // 부모가 있는 동안 계속 상위로 전파
11        while (parentMap.has(currentId)) {
12            const parentId = parentMap.get(currentId)!;
13            const currentNode = nodeMap.get(currentId);
14            const parentNode = nodeMap.get(parentId);
15
16            if (!currentNode || !parentNode) break;
17
18            // 중복 제거하며 메트릭 정보 상향 전파
19            this.mergeMetricsToParent(currentNode, parentNode);
20            currentId = parentId;
21        }
22    };
23
24    // 모든 리프 노드에서 시작
25    leafNodeIds.forEach(propagateToAncestors);
26}

1// 예시: NestJS 캐싱 인터셉터 패턴
2@Injectable()
3export class CacheInterceptor implements NestInterceptor {
4    async intercept(context: ExecutionContext, next: CallHandler) {
5        const cacheKey = this.generateCacheKey(context);
6
7        // 캐시 Hit: 즉시 반환
8        const cached = await this.cacheService.get(cacheKey);
9        if (cached) return of(cached);
10
11        // 캐시 Miss: 요청 처리 후 결과 캐싱
12        return next.handle().pipe(
13            tap(async (response) => {
14                await this.cacheService.set(cacheKey, response, TTL);
15            }),
16        );
17    }
18
19    // URL 기반 동적 캐시 키 생성
20    private generateCacheKey(ctx: ExecutionContext): string {
21        const request = ctx.switchToHttp().getRequest();
22        return `cache:${encodeURIComponent(request.url)}`;
23    }
24}

1부문(Unit)
2  └── 부서(Division)
3      └── 과제(Task) - 대/중/소과제
4          └── 액션플랜(ActionPlan)
5          └── KPI

13대 인덱스 (INDEX)
2  └── 대과제 (BIG)
3      └── 중과제 (MEDIUM)
4          └── 소과제 (SMALL)
5              └── 액션플랜 (ActionPlan)

1// 예시: Closure Table 엔티티 구조
2@Entity('node_closure')
3export class NodeClosure extends BaseEntity {
4    @PrimaryColumn({ type: 'bigint' })
5    id: number;
6
7    // 조상 (상위 노드)
8    @ManyToOne(() => Node, node => node.ancestorRelations, { onDelete: 'CASCADE' })
9    @JoinColumn({ name: 'ancestor_id' })
10    ancestor: Node;
11
12    // 자손 (하위 노드)
13    @ManyToOne(() => Node, node => node.descendantRelations, { onDelete: 'CASCADE' })
14    @JoinColumn({ name: 'descendant_id' })
15    descendant: Node;
16
17    // 관계 깊이: 0=자기 자신, 1=직접 부모-자식, 2=조부모-손자...
18    @Column({ type: 'int' })
19    depth: number;
20}
21
22// Node 엔티티 측 관계 정의
23@Entity('node')
24export class Node extends BaseEntity {
25    @PrimaryColumn({ type: 'bigint' })
26    id: number;
27
28    // 이 노드가 조상인 모든 관계
29    @OneToMany(() => NodeClosure, closure => closure.ancestor)
30    ancestorRelations: NodeClosure[];
31
32    // 이 노드가 자손인 모든 관계
33    @OneToMany(() => NodeClosure, closure => closure.descendant)
34    descendantRelations: NodeClosure[];
35
36    @Column({ type: 'varchar', length: 10 })
37    type: string;  // ROOT, LEVEL1, LEVEL2, LEVEL3
38}

1ROOT-1 (루트)
2  └── L1-1 (레벨1)
3      └── L2-1 (레벨2)
4          └── L3-1 (레벨3)

1// 예시: 직접 부모-자식 관계만 조회 (depth=1)
2async findDirectRelations(nodeIdList: number[]): Promise<NodeClosure[]> {
3    return await this.closureRepository.find({
4        where: [
5            { depth: 1, ancestor: In(nodeIdList) },  // 직접 자식들
6            { depth: 1, descendant: In(nodeIdList) }, // 직접 부모들
7        ],
8        relations: ['ancestor', 'descendant'],
9    });
10}
11
12// 예시: 특정 depth의 하위 노드 집계
13async getChildCountByDepth(nodeType: string, targetDepth: number) {
14    return await this.nodeRepository
15        .createQueryBuilder('n')
16        .leftJoin('node_closure', 'nc',
17            'nc.ancestor_id = n.id AND nc.depth = :depth',
18            { depth: targetDepth }
19        )
20        .where('n.type = :type', { type: nodeType })
21        .select('n.id', 'nodeId')
22        .addSelect('COUNT(nc.descendant_id)', 'childCount')
23        .groupBy('n.id')
24        .getRawMany();
25}
26
27// 예시: 루트 노드의 직접 자식 목록 조회
28async getDirectChildren(rootId: number): Promise<number[]> {
29    const result = await this.closureRepository
30        .createQueryBuilder('nc')
31        .select('nc.descendant_id', 'childId')
32        .where('nc.ancestor_id = :rootId', { rootId })
33        .andWhere('nc.depth = 1')  // 직접 자식만
34        .getRawMany();
35
36    return result.map(row => Number(row.childId));
37}

1// 예시: Closure Table 레코드 생성 알고리즘
2class TreeBuilder {
3    private closureRecords: NodeClosure[] = [];
4
5    // 모든 조상-자손 관계를 재귀적으로 생성
6    public buildClosureTable(rootNodes: TreeNode[]): NodeClosure[] {
7        this.closureRecords = [];
8        for (const root of rootNodes) {
9            this.traverseWithAncestors(root, []);
10        }
11        return this.closureRecords;
12    }
13
14    /**
15     * 핵심 알고리즘: DFS로 트리 순회하며 모든 조상과의 관계 생성
16     * ancestors: 현재까지 방문한 조상 노드 스택
17     */
18    private traverseWithAncestors(node: TreeNode, ancestors: TreeNode[]) {
19        // 모든 조상과의 관계 생성 (depth = 조상까지의 거리)
20        for (let i = 0; i < ancestors.length; i++) {
21            this.addClosureRecord(
22                ancestors[i],           // 조상
23                node,                   // 현재 노드 (자손)
24                ancestors.length - i    // depth: 거리
25            );
26        }
27
28        // 자기 자신과의 관계 (depth=0)
29        this.addClosureRecord(node, node, 0);
30
31        // 재귀: 자식 노드 처리 (백트래킹 패턴)
32        ancestors.push(node);
33        for (const child of node.children) {
34            this.traverseWithAncestors(child, ancestors);
35        }
36        ancestors.pop();
37    }
38
39    private addClosureRecord(ancestor: TreeNode, descendant: TreeNode, depth: number) {
40        this.closureRecords.push({
41            ancestor: { id: ancestor.id },
42            descendant: { id: descendant.id },
43            depth: depth,
44        });
45    }
46}

1// 예시: 트랜잭션 기반 배치 업데이트
2async batchUpsertClosure(treeBuilder: TreeBuilder) {
3    const closureData = treeBuilder.buildClosureTable();
4
5    await this.dataSource.transaction(async (manager) => {
6        // 기존 관계 전체 삭제 후 재생성 (Full Rebuild 전략)
7        await manager.createQueryBuilder()
8            .delete()
9            .from(NodeClosure)
10            .execute();
11
12        await manager.createQueryBuilder()
13            .insert()
14            .into(NodeClosure)
15            .values(closureData)
16            .execute();
17    });
18}

1// 예시: Closure Table 데이터로 메모리 트리 구축
2class TreeReconstructor {
3    buildTree(
4        directRelations: NodeClosure[],  // depth=1인 관계만 전달
5        nodeMap: Map<number, TreeNode>,
6    ): { leafIds: Set<number>; parentMap: Map<number, number> } {
7        const leafIds = new Set<number>();
8        const parentMap = new Map<number, number>();
9
10        directRelations.forEach(relation => {
11            const parentId = relation.ancestor.id;
12            const childId = relation.descendant.id;
13
14            if (parentId === childId) return;  // 자기 참조(depth=0) 스킵
15
16            const parentNode = nodeMap.get(parentId);
17            const childNode = nodeMap.get(childId);
18
19            if (!childNode || !parentNode) return;
20
21            leafIds.add(childId);
22            parentNode.children.push(childNode);  // 메모리 트리 구축
23            parentMap.set(childId, parentId);
24        });
25
26        return { leafIds, parentMap };
27    }
28}

1modules/
2├── task/           # 과제 도메인
3├── kpi/            # 성과지표 도메인
4├── action-plan/    # 액션플랜 도메인
5├── division/       # 부서/부문 도메인
6├── map/            # Map 시각화 도메인
7├── admin-master/   # 통합 어드민 도메인
8└── ...

1// 예시: 트리 생성 프로세스 (3단계)
2class HierarchyBuilder {
3    build(options: BuildOptions): TreeNode[] {
4        // 1. 부모-자식 관계 맵 구축 및 부가정보 매핑
5        const { leafIds, parentMap } = this.buildRelationMaps(
6            options.directRelations,
7            options.nodeMap
8        );
9
10        // 2. 리프 노드에서 상위 부모로 정보 집계
11        this.propagateInfoUpwards(options.nodeMap, parentMap, leafIds);
12
13        // 3. 루트 직속 하위 노드 추출
14        return this.extractChildren(options.nodeMap, leafIds);
15    }
16
17    // 부모-자식 관계 구축 (O(n) 성능)
18    private buildRelationMaps(
19        relations: NodeRelation[],
20        nodeMap: Map<number, TreeNode>,
21    ): { leafIds: Set<number>; parentMap: Map<number, number> } {
22        const leafIds = new Set<number>();
23        const parentMap = new Map<number, number>();
24
25        relations.forEach(relation => {
26            const parentId = relation.ancestor.id;
27            const childId = relation.descendant.id;
28
29            if (parentId === childId) return; // 순환 참조 방지
30
31            const parentNode = nodeMap.get(parentId);
32            const childNode = nodeMap.get(childId);
33
34            if (!childNode || !parentNode) return;
35
36            leafIds.add(childId);
37            parentNode.children.push(childNode);
38            parentMap.set(childId, parentId);
39        });
40
41        return { leafIds, parentMap };
42    }
43
44    // 루트 노드 추출 (부모가 없는 노드)
45    private extractChildren(
46        nodeMap: Map<number, TreeNode>,
47        leafIds: Set<number>
48    ): TreeNode[] {
49        return Array.from(nodeMap.entries())
50            .filter(([id]) => !leafIds.has(id))
51            .flatMap(([, node]) => node.children);
52    }
53}

1// 예시: 역할 기반 접근 제어 패턴
2export enum AuthLevel {
3    ADMIN = 'ADMIN',
4    VIEW = 'VIEW',
5    EDIT = 'EDIT',
6    EXPORT = 'EXPORT',
7}
8
9export const ROLES_KEY = 'roles';
10export const RequireRoles = (...roles: AuthLevel[]) =>
11    SetMetadata(ROLES_KEY, roles);
12
13// Guard 구현
14@Injectable()
15export class RoleGuard implements CanActivate {
16    async canActivate(context: ExecutionContext): Promise<boolean> {
17        const requiredRoles = this.reflector.getAllAndOverride<AuthLevel[]>(
18            ROLES_KEY,
19            [context.getHandler(), context.getClass()]
20        );
21
22        if (!requiredRoles) return true;
23
24        const request = context.switchToHttp().getRequest();
25        const user = request.user;
26
27        // OR 조건으로 권한 확인
28        const hasRole = user.roles.some(role => requiredRoles.includes(role));
29        if (!hasRole) {
30            throw new ForbiddenException('권한이 없습니다');
31        }
32
33        return true;
34    }
35}

1// 트리 구조 생성 공통 패턴
2const builder = new HierarchyBuilder(nodeList, relations, additionalInfo);
3const rootNodes = builder.build();

1@UseInterceptors(CacheInterceptor)
2@Get('/map/data')
3async getMapData() { ... }

1@AuditLog({ action: 'UPDATE' })
2@Patch('/resource/:id')
3async updateResource() { ... }

1@UseGuards(RoleGuard)
2@RequireRoles(AuthLevel.ADMIN)

1// 예시: 부문 코드 기반 Map 생성 흐름
2async generateMap(unitCode: string, mapType: MapType): Promise<MapData> {
3    // 1. 부문 정보 조회
4    const unit = await this.unitService.getByCode(unitCode);
5    const divisionCodes = unit.divisions.map(d => d.code);
6
7    // 2. 부서와 매핑된 노드 리스트 조회 (배치)
8    let nodeList = await this.nodeService.findByDivisions(divisionCodes);
9
10    // 3. Fallback: 노드가 없으면 유효한 부문의 노드 조회
11    if (nodeList.length === 0) {
12        nodeList = await this.findValidUnitNodes();
13    }
14
15    // 4. 노드 트리 생성
16    const treeData = await this.buildNodeTree(nodeList, mapType);
17
18    return MapData.of({
19        unitName: unit.name,
20        unitCode: unit.code,
21        children: treeData,
22    });
23}
24
25// 노드 리스트를 트리 구조로 변환
26async buildNodeTree(nodeList: Node[], mapType: MapType) {
27    const nodeIdList = nodeList.map(n => n.id);
28
29    // 배치 쿼리: 직접적 부모-자식 관계만 조회 (N+1 방지)
30    const directRelations = await this.nodeService.findDirectRelations(nodeIdList);
31
32    // 부가정보를 타입에 따라 조회
33    const additionalInfo = await this.getAdditionalInfo(nodeIdList, mapType);
34
35    // HierarchyBuilder를 통해 계층 구축
36    const builder = new HierarchyBuilder(nodeList, directRelations, additionalInfo);
37    return builder.build();
38}

1// 예시: d3.js 트리 시각화 핵심 구조
2import * as d3 from 'd3';
3
4function renderTreeMap(treeData, options = {}) {
5    const { width, height } = getDimensions();
6
7    // SVG 초기화
8    const svg = initializeSvg(width, height);
9
10    // d3.hierarchy: JSON을 계층 구조로 변환
11    const root = d3.hierarchy(treeData);
12
13    // 노드 간 간격 정의 (타입별 분기)
14    const separation = (a, b) => {
15        return (a.data.type === 'LEAF' || b.data.type === 'LEAF')
16            ? CONFIG.MIN_SEPARATION
17            : CONFIG.DEFAULT_SEPARATION;
18    };
19
20    // d3.tree: 트리 레이아웃 설정 및 좌표 계산
21    const treeLayout = d3.tree()
22        .nodeSize([CONFIG.NODE_WIDTH, CONFIG.NODE_HEIGHT])
23        .separation(separation);
24    treeLayout(root);
25
26    // 메인 그룹 요소
27    const g = svg.append("g");
28
29    // 트리 렌더링
30    renderNodes(g, root, options);
31    renderLinks(g, root);
32
33    // 미니맵 생성
34    createMiniMap(svg, g, root, { width, height });
35
36    // 줌 설정
37    initializeZoom(svg, g);
38}

1// 예시: SVG foreignObject를 통해 HTML 삽입
2function renderNodes(g, root, options) {
3    // 노드 그룹에 데이터 바인딩
4    const nodes = g.selectAll(".node")
5        .data(root.descendants(), d => d.data.id);
6
7    const nodeEnter = nodes.enter()
8        .append("g")
9        .attr("class", d => getNodeClass(d.depth));
10
11    // 위치 변환 적용
12    nodes.merge(nodeEnter)
13        .attr("transform", d => `translate(${d.x},${d.y})`);
14
15    // foreignObject: SVG 내에 HTML 요소 삽입
16    // → 복잡한 카드 UI를 퍼블리싱 결과물 그대로 사용 가능
17    nodeEnter.filter(d => d.depth > 0)
18        .append("foreignObject")
19        .attr("width", CONFIG.NODE_WIDTH)
20        .attr("height", CONFIG.NODE_HEIGHT)
21        .html(d => renderNodeTemplate(d.data));
22}

1// 예시: 미니맵 네비게이션
2function createMiniMap(svg, mainG, root, dimensions) {
3    const { width, height } = dimensions;
4    const miniMapWidth = 200;
5    const miniMapHeight = 150;
6
7    // 미니맵 위치 (우측 상단)
8    const miniMapX = width - miniMapWidth - 20;
9    const miniMapY = 20;
10
11    // 트리 전체 영역 계산
12    const allNodes = root.descendants();
13    const bounds = calculateBounds(allNodes);
14
15    // 미니맵 스케일 계산
16    const scale = Math.min(
17        miniMapWidth / bounds.width,
18        miniMapHeight / bounds.height
19    );
20
21    // 미니맵 컨테이너
22    const miniMapG = svg.append("g")
23        .attr("class", "minimap")
24        .attr("transform", `translate(${miniMapX}, ${miniMapY})`);
25
26    // 배경
27    miniMapG.append("rect")
28        .attr("width", miniMapWidth)
29        .attr("height", miniMapHeight)
30        .attr("fill", "#f9f9f9")
31        .attr("stroke", "#ccc");
32
33    // 노드를 원으로 표시
34    miniMapG.selectAll(".mini-node")
35        .data(allNodes)
36        .enter()
37        .append("circle")
38        .attr("cx", d => (d.x - bounds.minX) * scale)
39        .attr("cy", d => (d.y - bounds.minY) * scale)
40        .attr("r", 4)
41        .attr("fill", "#666");
42
43    // 뷰포트 표시기 (현재 보이는 영역)
44    const viewport = miniMapG.append("rect")
45        .attr("class", "viewport")
46        .attr("stroke", "#FF5733")
47        .attr("fill", "rgba(255, 87, 51, 0.1)");
48
49    // 줌 이벤트와 연동
50    svg.on("zoom.minimap", () => updateViewport(viewport, scale));
51}

1// 예시: 배치 업데이트 (Conflict resolution 패턴)
2async batchUpsert(dataModels: DataModel[]) {
3    await this.dataSource.transaction(async (manager) => {
4        await manager
5            .createQueryBuilder()
6            .insert()
7            .into(Entity)
8            .values(dataModels)
9            .orUpdate(
10                ['field1', 'field2', 'updated_at'],  // 업데이트할 컬럼
11                ['unique_key'],                       // Conflict 판단 키
12            )
13            .execute();
14    });
15}
16
17// 예시: 복합 키 기반 Upsert
18async monthlyDataUpsert(monthlyModels: MonthlyData[]): Promise<void> {
19    await this.dataSource.transaction(async (manager) => {
20        await manager
21            .createQueryBuilder()
22            .insert()
23            .into(MonthlyEntity)
24            .values(monthlyModels)
25            .orUpdate(
26                ['value', 'rate', 'updated_by', 'updated_at'],
27                ['entity_id', 'period'],  // 복합 키로 conflict resolution
28            )
29            .execute();
30    });
31}