@things-factory/kpi 9.0.31 → 9.0.33

package/server/service/kpi/aggregate-kpi.ts

@@ -2,6 +2,7 @@ import { getRepository } from '@things-factory/shell'
 import { Kpi } from './kpi'
 import { KpiMetric } from '../kpi-metric/kpi-metric'
 import { KpiValue, KpiValueInputType } from '../kpi-value/kpi-value'
+import { KpiOrgScope } from '../kpi-org-scope/kpi-org-scope'
 import { KpiFormulaService } from './kpi-formula.service'
 import { aggregateKpiMetricValue } from '../kpi-metric/aggregate-kpi-metric'
 import { KpiValueScoreService } from '../kpi-value/kpi-value-score.service'
@@ -33,34 +34,50 @@ export async function aggregateKpiValue(kpiId: string, domainId: string, context
     if (!metric) throw new Error(`KPI formula metric '${code}' not found`)
     codeValueMap[code] = await aggregateKpiMetricValue(metric.id, domainId, context)
   }
-  // group/date/period별로 값 매핑(가장 최근 기준, group key 조합)
-  const groupKey = v => [v.date, v.period, v.group].join('|')
-  const groupMap: Record<string, any> = {}
+  // org/date/period별로 값 매핑(가장 최근 기준, org key 조합)
+  const orgKey = v => [v.date, v.period, v.org].join('|')
+  const orgMap: Record<string, any> = {}
   for (const code of metricCodes) {
     for (const v of codeValueMap[code]) {
-      const key = groupKey(v)
-      groupMap[key] = groupMap[key] || { ...v, _values: {} }
-      groupMap[key]._values[code] = v.value
+      const key = orgKey(v)
+      orgMap[key] = orgMap[key] || { ...v, _values: {} }
+      orgMap[key]._values[code] = v.value
     }
   }
   // formula 계산 (js eval)
   const savedValues = []
-  for (const key in groupMap) {
-    const ctx = groupMap[key]._values
+  for (const key in orgMap) {
+    const ctx = orgMap[key]._values
     let value = null
     try {
       value = Function(...Object.keys(ctx), `return (${kpi.formula})`)(...Object.values(ctx))
     } catch (e) {
       value = null
     }
-    const valueDate = groupMap[key].date
-    const group = groupMap[key].group
+    const valueDate = orgMap[key].date
+    const org = orgMap[key].org
     const version = kpi.version || 1
     if (value == null || isNaN(value)) continue
-    // upsert(동일 KPI, valueDate, group, version) 기준으로 저장
+    // KpiOrgScope 처리 (org 문자열로 찾기 또는 생성)
+    const kpiOrgScopeRepo = getRepository(KpiOrgScope, context.state?.tx)
+    let kpiOrgScope = await kpiOrgScopeRepo.findOne({
+      where: { org: org, domain: { id: domainId } }
+    })
+    if (!kpiOrgScope) {
+      // 새 KpiOrgScope 생성
+      kpiOrgScope = await kpiOrgScopeRepo.save({
+        entityType: 'AutoAggregate',
+        entityId: `auto-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+        entityName: org,
+        org: org,
+        domain: kpi.domain
+      })
+    }
+
+    // upsert(동일 KPI, valueDate, kpiOrgScope, version) 기준으로 저장
     const repo = getRepository(KpiValue, context.state?.tx)
     const existing = await repo.findOne({
-      where: { kpi: { id: kpi.id }, valueDate, group, version, domain: { id: domainId } }
+      where: { kpi: { id: kpi.id }, valueDate, kpiOrgScope: { id: kpiOrgScope.id }, version, domain: { id: domainId } }
     })
     let entity = existing || repo.create()
     entity.kpi = kpi
@@ -68,7 +85,8 @@ export async function aggregateKpiValue(kpiId: string, domainId: string, context
     entity.version = version
     entity.valueDate = valueDate
     entity.value = value
-    entity.group = group
+    entity.kpiOrgScope = kpiOrgScope
+    entity.kpiOrgScopeId = kpiOrgScope.id
     entity.inputType = KpiValueInputType.AUTO
     entity.source = 'AUTO'
     entity.domain = kpi.domain

package/server/service/kpi/kpi-formula.service.ts

@@ -1,5 +1,8 @@
 import { getRepository } from '@things-factory/shell'
 import { KpiMetric } from '../kpi-metric/kpi-metric'
+import { Kpi } from './kpi'
+import { KpiValue } from '../kpi-value/kpi-value'
+import { KpiOrgScope } from '../kpi-org-scope/kpi-org-scope'
 
 /**
  * KPI formula 파싱/검증/매핑 유효성 검사 서비스
@@ -60,4 +63,102 @@ export class KpiFormulaService {
     // ...
     return { valid: errors.length === 0, errors }
   }
+
+  /**
+   * 계층 구조 KPI의 값을 자식 KPI들로부터 집계 계산
+   * @param kpiId 부모 KPI ID
+   * @param valueDate 계산 대상 날짜
+   * @param org 조직 단위
+   * @returns Promise<number | null> 집계된 값
+   */
+  async calculateHierarchicalValue(kpiId: string, valueDate: string, org?: string): Promise<number | null> {
+    const kpiRepo = getRepository(Kpi)
+    const kpi = await kpiRepo.findOne({
+      where: { id: kpiId },
+      relations: ['children']
+    })
+
+    if (!kpi || !kpi.children || kpi.children.length === 0) {
+      return null
+    }
+
+    const childValues: number[] = []
+    const childWeights: number[] = []
+
+    for (const child of kpi.children) {
+      let childValue: number | null = null
+      
+      if (child.isLeaf) {
+        // Leaf KPI인 경우 KpiValue에서 실제 값을 가져옴
+        const kpiValueRepo = getRepository(KpiValue)
+        let kpiValue: KpiValue | null = null
+        if (org) {
+          const kpiOrgScope = await getRepository(KpiOrgScope).findOne({
+            where: { org: org, domain: { id: child.domain?.id } }
+          })
+          if (kpiOrgScope) {
+            kpiValue = await kpiValueRepo.findOne({ 
+              where: { 
+                kpi: { id: child.id }, 
+                valueDate,
+                kpiOrgScope: { id: kpiOrgScope.id }
+              }
+            })
+          }
+        } else {
+          // org가 없는 경우 kpiOrgScope 없이 조회 
+          kpiValue = await kpiValueRepo.findOne({ 
+            where: { 
+              kpi: { id: child.id }, 
+              valueDate,
+              kpiOrgScope: null
+            }
+          })
+        }
+        childValue = kpiValue?.value || null
+      } else {
+        // 중간 노드인 경우 재귀적으로 계산
+        childValue = await this.calculateHierarchicalValue(child.id, valueDate, org)
+      }
+
+      if (childValue !== null) {
+        childValues.push(childValue)
+        childWeights.push(child.weight || 1)
+      }
+    }
+
+    if (childValues.length === 0) {
+      return null
+    }
+
+    // 가중 평균 계산
+    const totalWeight = childWeights.reduce((sum, weight) => sum + weight, 0)
+    const weightedSum = childValues.reduce((sum, value, index) => sum + value * childWeights[index], 0)
+    
+    return totalWeight > 0 ? weightedSum / totalWeight : null
+  }
+
+  /**
+   * KPI가 순환 참조를 생성하는지 확인
+   * @param kpiId KPI ID
+   * @param parentId 설정하려는 부모 KPI ID
+   * @returns Promise<boolean> 순환 참조 여부
+   */
+  async hasCircularReference(kpiId: string, parentId: string): Promise<boolean> {
+    if (kpiId === parentId) {
+      return true
+    }
+
+    const kpiRepo = getRepository(Kpi)
+    const parent = await kpiRepo.findOne({
+      where: { id: parentId },
+      relations: ['parent']
+    })
+
+    if (!parent || !parent.parent) {
+      return false
+    }
+
+    return await this.hasCircularReference(kpiId, parent.parent.id)
+  }
 }

package/server/service/kpi/kpi-history.ts

@@ -12,7 +12,6 @@ import { config } from '@things-factory/env'
 import { Domain, ScalarObject } from '@things-factory/shell'
 
 import { Kpi, KpiStatus, KpiPeriodType } from './kpi'
-import { KpiCategory } from '../kpi-category/kpi-category'
 import { KpiScores } from './kpi-grade.types'
 
 const ORMCONFIG = config.get('ormconfig', {})
@@ -48,13 +47,6 @@ export class KpiHistory implements HistoryEntityInterface<Kpi> {
   @Field({ nullable: true })
   description?: string
 
-  @ManyToOne(() => KpiCategory, { nullable: true })
-  @Field(type => KpiCategory, { nullable: true, description: 'Category to which this KPI belongs.' })
-  category?: KpiCategory
-
-  @RelationId((kpi: KpiHistory) => kpi.category)
-  categoryId?: string
-
   @Column({ nullable: true })
   @Field({ nullable: true, description: 'Calculation formula for the KPI.' })
   formula?: string

package/server/service/kpi/kpi-mutation.ts

@@ -5,11 +5,11 @@ import { getRepository } from '@things-factory/shell'
 import { createAttachment, deleteAttachmentsByRef } from '@things-factory/attachment-base'
 import { Kpi } from './kpi'
 import { NewKpi, KpiPatch } from './kpi-type'
-import { KpiCategory } from '../kpi-category/kpi-category'
 import { KpiHistory } from './kpi-history'
 import { KpiFormulaService } from './kpi-formula.service'
 import { Application, CallbackBase, registerSchedule, unregisterSchedule } from '@things-factory/scheduler-client'
 import { KpiValue } from '../kpi-value/kpi-value'
+import { KpiOrgScope } from '../kpi-org-scope/kpi-org-scope'
 import { Between } from 'typeorm'
 import { KpiMetric } from '../kpi-metric/kpi-metric'
 import { KpiMetricValue } from '../kpi-metric-value/kpi-metric-value'
@@ -29,13 +29,22 @@ export class KpiMutation {
   ): Promise<Kpi> {
     const { domain, user, tx } = context.state
 
-    let category = kpi.category
-      ? await getRepository(KpiCategory).findOne({ where: { id: kpi.category.id } })
+    let parent = kpi.parent
+      ? await getRepository(Kpi).findOne({ where: { id: kpi.parent.id, domain: { id: domain.id } } })
       : undefined
 
+    // 순환 참조 검사
+    if (parent) {
+      const formulaService = new KpiFormulaService()
+      const hasCircular = await formulaService.hasCircularReference(parent.id, parent.id)
+      if (hasCircular) {
+        throw new Error('Circular reference detected in KPI hierarchy')
+      }
+    }
+
     const result = await getRepository(Kpi, tx).save({
       ...kpi,
-      category,
+      parent,
       domain,
       creator: user,
       updater: user
@@ -114,14 +123,23 @@ export class KpiMutation {
       where: { domain: { id: domain.id }, id }
     })
 
-    let category = patch.category
-      ? await getRepository(KpiCategory).findOne({ where: { id: patch.category.id } })
-      : kpi.category
+    let parent = patch.parent
+      ? await getRepository(Kpi).findOne({ where: { id: patch.parent.id, domain: { id: domain.id } } })
+      : patch.parent === null ? null : kpi.parent
+
+    // 순환 참조 검사 (parent가 변경되는 경우)
+    if (parent && parent.id !== kpi.parentId) {
+      const formulaService = new KpiFormulaService()
+      const hasCircular = await formulaService.hasCircularReference(kpi.id, parent.id)
+      if (hasCircular) {
+        throw new Error('Circular reference detected in KPI hierarchy')
+      }
+    }
 
     const result = await repository.save({
       ...kpi,
       ...patch,
-      category,
+      parent,
       updater: user
     })
 
@@ -383,8 +401,6 @@ export class KpiMutation {
       ...kpi,
       name: kpiHistory.name,
       description: kpiHistory.description,
-      category: kpiHistory.category,
-      categoryId: kpiHistory.categoryId,
       formula: kpiHistory.formula,
       active: kpiHistory.active,
       state: 'DRAFT',
@@ -400,7 +416,7 @@ export class KpiMutation {
   async calculateKpiValue(
     @Arg('kpiId') kpiId: string,
     @Arg('valueDate', { nullable: true }) valueDate: string,
-    @Arg('group', { nullable: true }) group: string,
+    @Arg('org', { nullable: true }) org: string,
     @Ctx() context: ResolverContext
   ): Promise<KpiValue> {
     const { domain, user, tx } = context.state
@@ -443,7 +459,7 @@ export class KpiMutation {
             metric: { id: metric.id },
             valueDate: valueDateToUse,
             periodType,
-            group: group ?? '',
+            org: org ?? '',
             domain: { id: domain.id }
           }
         })
@@ -458,7 +474,7 @@ export class KpiMutation {
               metric: { id: metric.id },
               valueDate: Between(startDate, endDate),
               periodType: metric.periodType,
-              group: group ?? '',
+              org: org ?? '',
               domain: { id: domain.id }
             }
           })
@@ -475,19 +491,39 @@ export class KpiMutation {
     const ast = parseFormula(kpi.formula)
     const provider = new KpiMetricValueProvider({
       valueDate: valueDateToUse,
-      group,
+      org,
       domainId: domain.id,
       tx
     })
     const evalContext = { functions: builtinFunctions, provider }
     const kpiValueResult = await evaluateFormula(ast, evalContext)
 
-    // 5. KPI Value upsert
+    // 5. KpiOrgScope 처리
+    let kpiOrgScope: KpiOrgScope | null = null
+    if (org) {
+      kpiOrgScope = await getRepository(KpiOrgScope, tx).findOne({
+        where: { org: org, domain: { id: domain.id } }
+      })
+      if (!kpiOrgScope) {
+        // 새 KpiOrgScope 생성
+        kpiOrgScope = await getRepository(KpiOrgScope, tx).save({
+          entityType: 'KpiCalculation',
+          entityId: `calc-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+          entityName: org,
+          org: org,
+          domain,
+          creator: user,
+          updater: user
+        })
+      }
+    }
+
+    // 6. KPI Value upsert
     let kpiValue = await kpiValueRepo.findOne({
       where: {
         kpi: { id: kpi.id },
         valueDate: valueDateToUse,
-        group: group ?? '',
+        kpiOrgScope: kpiOrgScope ? { id: kpiOrgScope.id } : null,
         version: kpi.version,
         domain: { id: domain.id }
       }
@@ -496,17 +532,21 @@ export class KpiMutation {
       kpiValue.value = kpiValueResult
       kpiValue.updater = user
     } else {
-      kpiValue = kpiValueRepo.create({
+      const createData: any = {
         kpi,
         kpiId: kpi.id,
         version: kpi.version,
         valueDate: valueDateToUse,
         value: kpiValueResult,
-        group: group ?? '',
         domain,
         creator: user,
         updater: user
-      })
+      }
+      if (kpiOrgScope) {
+        createData.kpiOrgScope = kpiOrgScope
+        createData.kpiOrgScopeId = kpiOrgScope.id
+      }
+      kpiValue = Object.assign(new KpiValue(), createData)
     }
     return await kpiValueRepo.save(kpiValue)
   }

package/server/service/kpi/kpi-query.ts

@@ -1,16 +1,75 @@
+import { IsNull } from 'typeorm'
 import { Resolver, Query, FieldResolver, Root, Args, Arg, Ctx, Directive } from 'type-graphql'
 import { Attachment } from '@things-factory/attachment-base'
 import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
 import { User } from '@things-factory/auth-base'
+import type ResolverContext from '@things-factory/auth-base'
 import { Kpi } from './kpi'
 import { KpiList } from './kpi-type'
 import { KpiValue } from '../kpi-value/kpi-value'
 import { KpiHistory } from './kpi-history'
 import { Int } from 'type-graphql'
-import { KpiCategory } from '../kpi-category/kpi-category'
 
 @Resolver(Kpi)
 export class KpiQuery {
+  @Directive('@privilege(category: "kpi", privilege: "query", domainOwnerGranted: true, superUserGranted: true)')
+  @Query(returns => [Kpi], { description: 'Fetch root KPIs (KPIs without parent)' })
+  async kpisLevel0(@Ctx() context: ResolverContext): Promise<Kpi[]> {
+    const { domain } = context.state
+
+    return await getRepository(Kpi).find({
+      where: { domain: { id: domain.id }, parent: null },
+      order: { name: 'ASC' }
+    })
+  }
+
+  @Directive('@privilege(category: "kpi", privilege: "query", domainOwnerGranted: true, superUserGranted: true)')
+  @Query(returns => [Kpi], {
+    description:
+      'Fetch first level child KPIs. If rootId is provided, get children of that parent. If not, get all level 1 KPIs (children of root KPIs)'
+  })
+  async kpisLevel1(
+    @Arg('rootId', {
+      nullable: true,
+      description: 'ID of the parent KPI to get level 1 children. If not provided, returns all level 1 KPIs'
+    })
+    rootId: string,
+    @Ctx() context: ResolverContext
+  ): Promise<Kpi[]> {
+    const { domain } = context.state
+
+    let whereCondition: any = { domain: { id: domain.id } }
+
+    if (rootId) {
+      // 특정 부모의 자식들
+      whereCondition.parent = { id: rootId }
+    } else {
+      // 모든 level 1 KPI들 (root KPI들의 직계 자식들)
+      // 부모가 있으면서 부모의 부모가 null인 KPI들
+      const kpis = await getRepository(Kpi)
+        .createQueryBuilder('kpi')
+        .leftJoinAndSelect('kpi.parent', 'parent')
+        .leftJoinAndSelect('kpi.children', 'children')
+        .leftJoinAndSelect('children.children', 'grandchildren')
+        .where('kpi.domain = :domainId', { domainId: domain.id })
+        .andWhere('parent.id IS NOT NULL')
+        .andWhere('parent.parent IS NULL')
+        .orderBy('kpi.name', 'ASC')
+        .getMany()
+
+      return kpis
+    }
+
+    // rootId 제공된 경우
+    const kpis = await getRepository(Kpi).find({
+      where: whereCondition,
+      relations: ['children', 'children.children'],
+      order: { name: 'ASC' }
+    })
+
+    return kpis
+  }
+
   @Directive('@privilege(category: "kpi", privilege: "query", domainOwnerGranted: true, superUserGranted: true)')
   @Query(returns => Kpi!, { nullable: true, description: 'Fetch a single KPI by its unique identifier.' })
   async kpi(
@@ -33,7 +92,10 @@ export class KpiQuery {
       domain,
       params,
       repository: await getRepository(Kpi),
-      searchables: ['name', 'description']
+      searchables: ['name', 'description'],
+      filtersMap: {
+        parent: { columnName: 'id', relationColumn: 'parent' }
+      }
     })
 
     const [items, total] = await queryBuilder.getManyAndCount()
@@ -41,6 +103,13 @@ export class KpiQuery {
     return { items, total }
   }
 
+  @FieldResolver(type => [Kpi])
+  children(@Root() kpi: Kpi): Promise<Kpi[]> {
+    return getRepository(Kpi).find({
+      where: { parent: { id: kpi.id } }
+    })
+  }
+
   @FieldResolver(type => String)
   async thumbnail(@Root() kpi: Kpi): Promise<string | undefined> {
     const attachment: Attachment = await getRepository(Attachment).findOne({
@@ -70,10 +139,26 @@ export class KpiQuery {
   }
 
   @FieldResolver(type => KpiValue, { nullable: true })
-  async value(@Root() kpi: Kpi, @Ctx() context): Promise<KpiValue | null> {
+  async value(
+    @Root() kpi: Kpi,
+    @Ctx() context,
+    @Arg('orgScope', { nullable: true, description: 'Organization scope filter for value' }) orgScope?: string
+  ): Promise<KpiValue | null> {
     const { domain } = context.state
+
+    let whereCondition: any = {
+      domain: { id: domain.id },
+      kpi: { id: kpi.id }
+    }
+
+    // orgScope 필터가 있으면 KpiOrgScope로 필터링
+    if (orgScope) {
+      whereCondition.kpiOrgScope = { org: orgScope }
+    }
+
     return await getRepository(KpiValue).findOne({
-      where: { domain: { id: domain.id }, kpi: { id: kpi.id } },
+      where: whereCondition,
+      relations: ['kpiOrgScope'],
       order: { valueDate: 'DESC' }
     })
   }
@@ -88,10 +173,10 @@ export class KpiQuery {
     return kpi.vizMeta?.unit
   }
 
-  @FieldResolver(type => KpiCategory, { nullable: true })
-  async category(@Root() kpi: Kpi): Promise<KpiCategory | null> {
-    if (!kpi.categoryId) return null
-    return await getRepository(KpiCategory).findOneBy({ id: kpi.categoryId })
+  @FieldResolver(type => Kpi, { nullable: true })
+  async parent(@Root() kpi: Kpi): Promise<Kpi | null> {
+    if (!kpi.parentId) return null
+    return await getRepository(Kpi).findOneBy({ id: kpi.parentId })
   }
 
   @FieldResolver(type => [KpiHistory], { nullable: true })
@@ -110,4 +195,30 @@ export class KpiQuery {
     else qb.limit(1)
     return await qb.getMany()
   }
+
+  @Directive('@privilege(category: "kpi", privilege: "query", domainOwnerGranted: true, superUserGranted: true)')
+  @Query(returns => [Kpi], { description: 'Fetch KPIs in hierarchical tree structure' })
+  async kpiTree(@Ctx() context: ResolverContext): Promise<Kpi[]> {
+    const { domain } = context.state
+
+    return await getRepository(Kpi).find({
+      where: { domain: { id: domain.id }, parent: IsNull() },
+      relations: ['children', 'children.children', 'children.children.children'],
+      order: { name: 'ASC' }
+    })
+  }
+
+  @Directive('@privilege(category: "kpi", privilege: "query", domainOwnerGranted: true, superUserGranted: true)')
+  @Query(returns => [Kpi], { description: 'Fetch child KPIs of a given parent KPI' })
+  async kpiChildren(
+    @Arg('parentId', { description: 'ID of the parent KPI' }) parentId: string,
+    @Ctx() context: ResolverContext
+  ): Promise<Kpi[]> {
+    const { domain } = context.state
+
+    return await getRepository(Kpi).find({
+      where: { domain: { id: domain.id }, parent: { id: parentId } },
+      order: { name: 'ASC' }
+    })
+  }
 }

package/server/service/kpi/kpi-type.ts

@@ -15,8 +15,11 @@ export class NewKpi {
   @Field({ nullable: true, description: 'Detailed description of the KPI.' })
   description?: string
 
-  @Field(type => ObjectRef, { nullable: true, description: 'Reference to the category to which this KPI belongs.' })
-  category?: ObjectRef
+  @Field(type => ObjectRef, { nullable: true, description: 'Reference to the parent KPI in hierarchical structure.' })
+  parent?: ObjectRef
+
+  @Field({ nullable: true, description: 'Indicates whether this KPI is a leaf node (has actual measured values).' })
+  isLeaf?: boolean
 
   @Field({ nullable: true, description: 'Calculation formula for the KPI, using metric codes and operators.' })
   formula?: string
@@ -79,8 +82,11 @@ export class KpiPatch {
   @Field({ nullable: true, description: 'Detailed description of the KPI.' })
   description?: string
 
-  @Field(type => ObjectRef, { nullable: true, description: 'Reference to the category to which this KPI belongs.' })
-  category?: ObjectRef
+  @Field(type => ObjectRef, { nullable: true, description: 'Reference to the parent KPI in hierarchical structure.' })
+  parent?: ObjectRef
+
+  @Field({ nullable: true, description: 'Indicates whether this KPI is a leaf node (has actual measured values).' })
+  isLeaf?: boolean
 
   @Field({ nullable: true, description: 'Calculation formula for the KPI, using metric codes and operators.' })
   formula?: string

package/server/service/kpi/kpi.ts

@@ -15,7 +15,6 @@ import { ObjectType, Field, Int, ID, registerEnumType } from 'type-graphql'
 
 import { Domain } from '@things-factory/shell'
 import { User } from '@things-factory/auth-base'
-import { KpiCategory } from '../kpi-category/kpi-category'
 import { config } from '@things-factory/env'
 import { ScalarObject } from '@things-factory/shell'
 
@@ -78,6 +77,9 @@ registerEnumType(KpiPeriodType, {
   where: '"deleted_at" IS NULL',
   unique: true
 })
+@Index('ix_kpi_hierarchy', (kpi: Kpi) => [kpi.domain, kpi.parent], {
+  where: '"deleted_at" IS NULL'
+})
 @ObjectType({
   description:
     'KPI entity. Represents a key performance indicator with calculation formula, target, category, and other attributes.'
@@ -111,13 +113,21 @@ export class Kpi {
   @Field({ nullable: true, description: 'Detailed description of the KPI.' })
   description?: string
 
-  @ManyToOne(() => KpiCategory, { nullable: true })
-  @Field(type => KpiCategory, { nullable: true, description: 'Category to which this KPI belongs.' })
-  category?: KpiCategory
+  @ManyToOne(() => Kpi, { nullable: true })
+  @Field(type => Kpi, { nullable: true, description: 'Parent KPI in hierarchical structure.' })
+  parent?: Kpi
+
+  @RelationId((kpi: Kpi) => kpi.parent)
+  @Field({ nullable: true, description: 'ID of the parent KPI.' })
+  parentId?: string
+
+  @OneToMany(() => Kpi, kpi => kpi.parent)
+  @Field(type => [Kpi], { nullable: true, description: 'Child KPIs in hierarchical structure.' })
+  children?: Kpi[]
 
-  @RelationId((kpi: Kpi) => kpi.category)
-  @Field({ nullable: true, description: 'ID of the category for this KPI.' })
-  categoryId?: string
+  @Column({ nullable: false, default: true })
+  @Field({ nullable: true, description: 'Indicates whether this KPI is a leaf node (has actual measured values).' })
+  isLeaf?: boolean
 
   @Column({
     nullable: true,