@things-factory/kpi 1.0.0-alpha.5 → 9.0.9

package/server/migrations/1752191090459-SeedKpiGrade.ts

@@ -0,0 +1,270 @@
+import { MigrationInterface, QueryRunner } from 'typeorm'
+import { Domain, getRepository } from '@things-factory/shell'
+import { KpiGrade } from '../service/kpi-grade/kpi-grade.js'
+import { Kpi } from '../service/kpi/kpi.js'
+
+const GRADE_SEED = [
+  {
+    kpiName: '일정성과 수준 평가',
+    version: 1,
+    grades: [
+      {
+        name: '1점',
+        minValue: 1,
+        maxValue: 1,
+        score: 1,
+        description: '달성상황(기후, 일반변화 등)과 인근주민 민원 등이 발생하여 공기가 지연됨.'
+      },
+      {
+        name: '2점',
+        minValue: 2,
+        maxValue: 2,
+        score: 2,
+        description: '달성상황(기후, 일반변화 등)과 인근주민 민원 등이 발생하여 공기를 맞춤.'
+      },
+      {
+        name: '3점',
+        minValue: 3,
+        maxValue: 3,
+        score: 3,
+        description: '달성상황(기후, 일반변화 등)과 인근주민 민원 등이 발생하지 않으나 공기를 맞춤.'
+      },
+      {
+        name: '4점',
+        minValue: 4,
+        maxValue: 4,
+        score: 4,
+        description: '달성상황(기후, 일반변화 등)과 인근주민 민원 등이 발생하지 않으며 공기를 단축함.'
+      },
+      {
+        name: '5점',
+        minValue: 5,
+        maxValue: 5,
+        score: 5,
+        description: '달성상황(기후, 일반변화 등)과 인근주민 민원 등이 발생하지 않으며 공기를 단축함.'
+      }
+    ]
+  },
+  {
+    kpiName: '비용성과 수준 평가',
+    version: 1,
+    grades: [
+      {
+        name: '1점',
+        minValue: 1,
+        maxValue: 1,
+        score: 1,
+        description: '공사비 변동과 민원 등이 발생하여 공사비 관리가 미흡함.'
+      },
+      {
+        name: '2점',
+        minValue: 2,
+        maxValue: 2,
+        score: 2,
+        description: '공사비 변동과 민원 등이 발생하여 공사비 관리가 미흡함.'
+      },
+      {
+        name: '3점',
+        minValue: 3,
+        maxValue: 3,
+        score: 3,
+        description: '공사비 변동과 민원 등이 발생하였으나 공사비 관리를 적정하게 수행함.'
+      },
+      {
+        name: '4점',
+        minValue: 4,
+        maxValue: 4,
+        score: 4,
+        description: '공사비 변동과 민원 등이 발생하지 않으며 공사비 관리를 적정하게 수행함.'
+      },
+      {
+        name: '5점',
+        minValue: 5,
+        maxValue: 5,
+        score: 5,
+        description: '공사비 변동과 민원 등이 발생하지 않으며 매우 훌륭하게 수행함.'
+      }
+    ]
+  },
+  {
+    kpiName: '품질성과 수준 평가',
+    version: 1,
+    grades: [
+      {
+        name: '1점',
+        minValue: 1,
+        maxValue: 1,
+        score: 1,
+        description: '법적 요구 수준에 못 미치거나 공사 완성도의 개선이 매우 필요한 경우'
+      },
+      {
+        name: '2점',
+        minValue: 2,
+        maxValue: 2,
+        score: 2,
+        description: '법적 요구 수준을 일부 만족하나, 공사 완성도의 개선이 일부 필요한 경우'
+      },
+      { name: '3점', minValue: 3, maxValue: 3, score: 3, description: '법적 요구 수준을 충족하는 수준' },
+      {
+        name: '4점',
+        minValue: 4,
+        maxValue: 4,
+        score: 4,
+        description: '법적 요구 수준을 만족하며, 품질관리 활동이 능동적인 경우'
+      },
+      {
+        name: '5점',
+        minValue: 5,
+        maxValue: 5,
+        score: 5,
+        description: '법적 요구 수준을 만족하며, 품질관리 활동이 매우 능동적인 경우'
+      }
+    ]
+  },
+  {
+    kpiName: '안전성과 수준 평가',
+    version: 1,
+    grades: [
+      {
+        name: '1점',
+        minValue: 1,
+        maxValue: 1,
+        score: 1,
+        description: '법적 요구 수준을 미달하거나 안전관리 활동이 미흡한 경우'
+      },
+      {
+        name: '2점',
+        minValue: 2,
+        maxValue: 2,
+        score: 2,
+        description: '법적 요구 수준을 일부 만족하나, 안전관리 활동이 다소 필요한 경우'
+      },
+      { name: '3점', minValue: 3, maxValue: 3, score: 3, description: '법적 요구 수준을 충족하는 수준' },
+      {
+        name: '4점',
+        minValue: 4,
+        maxValue: 4,
+        score: 4,
+        description: '법적 요구 수준을 만족하며, 안전관리 활동이 능동적인 경우'
+      },
+      {
+        name: '5점',
+        minValue: 5,
+        maxValue: 5,
+        score: 5,
+        description: '법적 요구 수준을 만족하며, 안전관리 활동이 매우 능동적인 경우'
+      }
+    ]
+  },
+  {
+    kpiName: '환경성과 수준 평가',
+    version: 1,
+    grades: [
+      {
+        name: '1점',
+        minValue: 1,
+        maxValue: 1,
+        score: 1,
+        description: '법적 요구 수준에 못 미치거나 환경관리 활동의 개선이 매우 필요한 경우'
+      },
+      {
+        name: '2점',
+        minValue: 2,
+        maxValue: 2,
+        score: 2,
+        description: '법적 요구 수준을 일부 만족하나, 환경관리 활동이 다소 필요한 경우'
+      },
+      { name: '3점', minValue: 3, maxValue: 3, score: 3, description: '법적 요구 수준을 충족하는 수준' },
+      {
+        name: '4점',
+        minValue: 4,
+        maxValue: 4,
+        score: 4,
+        description: '법적 요구 수준을 만족하며, 환경관리 활동의 효율성을 다소 높은 수준'
+      },
+      {
+        name: '5점',
+        minValue: 5,
+        maxValue: 5,
+        score: 5,
+        description: '법적 요구 수준을 만족하며, 환경관리 활동의 효율성이 확연히 높은 수준'
+      }
+    ]
+  },
+  {
+    kpiName: '생산성과 수준 평가',
+    version: 1,
+    grades: [
+      {
+        name: '1점',
+        minValue: 1,
+        maxValue: 1,
+        score: 1,
+        description: '인력 및 장비 투입 규모에 대한 효율성이 매우 낮은 수준'
+      },
+      {
+        name: '2점',
+        minValue: 2,
+        maxValue: 2,
+        score: 2,
+        description: '인력 및 장비 투입 규모가 법적 요구 수준을 충족하나, 연계에 비해 미흡함.'
+      },
+      {
+        name: '3점',
+        minValue: 3,
+        maxValue: 3,
+        score: 3,
+        description: '인력 및 장비 투입 규모가 법적 요구 수준을 충족하는 수준'
+      },
+      {
+        name: '4점',
+        minValue: 4,
+        maxValue: 4,
+        score: 4,
+        description: '투입 규모가 법적 요구 수준을 충족하며, 효율성이 다소 높은 수준'
+      },
+      {
+        name: '5점',
+        minValue: 5,
+        maxValue: 5,
+        score: 5,
+        description: '투입 규모가 법적 요구 수준을 충족하며, 효율성이 확연히 높은 수준'
+      }
+    ]
+  }
+]
+
+export class SeedKpiGrade1752191090459 implements MigrationInterface {
+  public async up(queryRunner: QueryRunner): Promise<any> {
+    const repository = getRepository(KpiGrade)
+    const kpiRepository = getRepository(Kpi)
+    const domain: Domain = await getRepository(Domain).findOneBy({ name: 'SYSTEM' })
+
+    for (const seed of GRADE_SEED) {
+      const kpi = await kpiRepository.findOneBy({ name: seed.kpiName, domain: { id: domain.id } })
+      if (!kpi) continue
+      for (const grade of seed.grades) {
+        await repository.save({
+          ...grade,
+          version: seed.version,
+          kpi,
+          domain
+        })
+      }
+    }
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<any> {
+    const repository = getRepository(KpiGrade)
+    const kpiRepository = getRepository(Kpi)
+    const domain: Domain = await getRepository(Domain).findOneBy({ name: 'SYSTEM' })
+
+    for (const seed of GRADE_SEED) {
+      const kpi = await kpiRepository.findOneBy({ name: seed.kpiName, domain: { id: domain.id } })
+      if (!kpi) continue
+      for (const grade of seed.grades.reverse()) {
+        await repository.delete({ name: grade.name, kpi: { id: kpi.id }, domain: { id: domain.id } })
+      }
+    }
+  }
+}

package/server/migrations/index.ts

@@ -0,0 +1,9 @@
+const glob = require('glob')
+const path = require('path')
+
+export var migrations = []
+
+glob.sync(path.resolve(__dirname, '.', '**', '*.js')).forEach(function(file) {
+  if (file.indexOf('index.js') !== -1) return
+  migrations = migrations.concat(Object.values(require(path.resolve(file))) || [])
+})

package/server/routes.ts

@@ -1,3 +1,6 @@
+import { aggregateKpiMetricValue } from './service/kpi-metric/aggregate-kpi-metric'
+import { aggregateKpiValue } from './service/kpi/aggregate-kpi'
+
 process.on('bootstrap-module-global-public-route' as any, (app, globalPublicRouter) => {
   /*
    * can add global public routes to application (auth not required, tenancy not required)
@@ -5,6 +8,58 @@ process.on('bootstrap-module-global-public-route' as any, (app, globalPublicRout
    * ex) routes.get('/path', async(context, next) => {})
    * ex) routes.post('/path', async(context, next) => {})
    */
+
+  // KPI-Metric 스케줄러 콜백 엔드포인트
+  globalPublicRouter.post('/callback-schedule-for-kpi-metric', async (context, next) => {
+    const { client } = context.request.body
+
+    if (!client || typeof client !== 'object') {
+      throw new Error('client property should be a part of callback body.')
+    }
+
+    const { group: domainId, key: metricId } = client
+
+    if (!domainId || !metricId) {
+      throw new Error(`group(${domainId}) and key(${metricId}) properties should not be empty`)
+    }
+
+    try {
+      // KPI-Metric 집계/자동화 함수 호출
+      const values = await aggregateKpiMetricValue(metricId, domainId, context)
+      console.log(`[KPI-Metric Schedule Callback] domainId=${domainId}, metricId=${metricId}, values=`, values)
+      context.status = 200
+    } catch (err) {
+      console.error('[KPI-Metric Schedule Callback][ERROR]', err)
+      context.status = 500
+      context.body = { error: err.message || String(err) }
+    }
+  })
+
+  // KPI 스케줄러 콜백 엔드포인트
+  globalPublicRouter.post('/callback-schedule-for-kpi', async (context, next) => {
+    const { client } = context.request.body
+
+    if (!client || typeof client !== 'object') {
+      throw new Error('client property should be a part of callback body.')
+    }
+
+    const { group: domainId, key: kpiId } = client
+
+    if (!domainId || !kpiId) {
+      throw new Error(`group(${domainId}) and key(${kpiId}) properties should not be empty`)
+    }
+
+    try {
+      // KPI 집계/자동화 함수 호출
+      const values = await aggregateKpiValue(kpiId, domainId, context)
+      console.log(`[KPI Schedule Callback] domainId=${domainId}, kpiId=${kpiId}, values=`, values)
+      context.status = 200
+    } catch (err) {
+      console.error('[KPI Schedule Callback][ERROR]', err)
+      context.status = 500
+      context.body = { error: err.message || String(err) }
+    }
+  })
 })
 
 process.on('bootstrap-module-global-private-route' as any, (app, globalPrivateRouter) => {

package/server/service/index.ts

@@ -1,8 +1,6 @@
 /* EXPORT ENTITY TYPES */
 export * from './kpi/kpi'
 export * from './kpi/kpi-type'
-export * from './kpi-formula/kpi-formula'
-export * from './kpi-formula/kpi-formula-type'
 export * from './kpi-category/kpi-category'
 export * from './kpi-category/kpi-category-type'
 export * from './kpi-grade/kpi-grade'
@@ -11,19 +9,19 @@ export * from './kpi-value/kpi-value'
 export * from './kpi-value/kpi-value-type'
 export * from './kpi-metric/kpi-metric'
 export * from './kpi-metric/kpi-metric-type'
+export * from './kpi-alert'
 
 /* IMPORT ENTITIES AND RESOLVERS */
 import { entities as KpiEntities, resolvers as KpiResolvers } from './kpi'
-import { entities as KpiFormulaEntities, resolvers as KpiFormulaResolvers } from './kpi-formula'
 import { entities as KpiCategoryEntities, resolvers as KpiCategoryResolvers } from './kpi-category'
 import { entities as KpiGradeEntities, resolvers as KpiGradeResolvers } from './kpi-grade'
 import { entities as KpiValueEntities, resolvers as KpiValueResolvers } from './kpi-value'
 import { entities as KpiMetricEntities, resolvers as KpiMetricResolvers } from './kpi-metric'
+import { resolvers as KpiAlertResolvers } from './kpi-alert'
 
 export const entities = [
   /* ENTITIES */
   ...KpiEntities,
-  ...KpiFormulaEntities,
   ...KpiCategoryEntities,
   ...KpiGradeEntities,
   ...KpiValueEntities,
@@ -34,10 +32,10 @@ export const schema = {
   resolverClasses: [
     /* RESOLVER CLASSES */
     ...KpiResolvers,
-    ...KpiFormulaResolvers,
     ...KpiCategoryResolvers,
     ...KpiGradeResolvers,
     ...KpiValueResolvers,
-    ...KpiMetricResolvers
+    ...KpiMetricResolvers,
+    ...KpiAlertResolvers
   ]
 }

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

@@ -0,0 +1,82 @@
+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 { KpiFormulaService } from './kpi-formula.service'
+import { aggregateKpiMetricValue } from '../kpi-metric/aggregate-kpi-metric'
+
+/**
+ * KPI 단위 집계/산식 자동화 함수
+ * @param kpiId KPI ID
+ * @param domainId 도메인 ID
+ * @param context ResolverContext
+ * @returns 저장된 KPI Value 배열
+ */
+export async function aggregateKpiValue(kpiId: string, domainId: string, context: ResolverContext) {
+  const tx = context.state?.tx || getRepository(Kpi).manager
+
+  // 1. KPI 정보 조회
+  const kpi = await getRepository(Kpi).findOne({ where: { id: kpiId, domain: { id: domainId } } })
+  if (!kpi) throw new Error('KPI 정보 없음')
+  if (!kpi.active) throw new Error('비활성화된 KPI')
+  if (!kpi.formula) throw new Error('KPI formula 없음')
+
+  // 2. formula 파싱 및 metric code별 값 집계
+  const formulaService = new KpiFormulaService()
+  const metricCodes = formulaService.extractMetricCodes(kpi.formula)
+  const codeValueMap: Record<string, any[]> = {}
+  for (const code of metricCodes) {
+    // code로 metric 찾기
+    const metric = await getRepository(KpiMetric).findOne({ where: { name: code, domain: { id: domainId } } })
+    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?.key01, v.group?.key02, v.group?.key03, v.group?.key04, v.group?.key05].join('|')
+  const groupMap: 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
+    }
+  }
+  // formula 계산 (js eval)
+  const savedValues = []
+  for (const key in groupMap) {
+    const ctx = groupMap[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 groupId = groupMap[key].group?.key01
+    const groupType = groupMap[key].group?.key02
+    const version = kpi.version || 1
+    if (value == null || isNaN(value)) continue
+    // upsert(동일 KPI, valueDate, groupId, groupType, version) 기준으로 저장
+    const repo = getRepository(KpiValue, context.state?.tx)
+    const existing = await repo.findOne({
+      where: { kpi: { id: kpi.id }, valueDate, groupId, groupType, version, domain: { id: domainId } }
+    })
+    let entity = existing || repo.create()
+    entity.kpi = kpi
+    entity.kpiId = kpi.id
+    entity.version = version
+    entity.valueDate = valueDate
+    entity.value = value
+    entity.groupId = groupId
+    entity.groupType = groupType
+    entity.inputType = KpiValueInputType.AUTO
+    entity.source = 'AUTO'
+    entity.domain = kpi.domain
+    entity.creator = context.state?.user
+    entity.updater = context.state?.user
+    entity = await repo.save(entity)
+    savedValues.push(entity)
+  }
+  return savedValues
+}

package/server/service/kpi/event-subscriber.ts

@@ -14,4 +14,16 @@ export class KpiHistoryEntitySubscriber extends HistoryEntitySubscriber<Kpi, Kpi
   public get historyEntity() {
     return KpiHistory
   }
+
+  public async afterInsert(event): Promise<void> {
+    if (event.entity.state == 'RELEASE') {
+      await super.afterInsert(event as any)
+    }
+  }
+
+  public async afterUpdate(event): Promise<void> {
+    if (event.entity.state == 'RELEASE') {
+      await super.afterUpdate(event as any)
+    }
+  }
 }

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

@@ -0,0 +1,63 @@
+import { getRepository } from '@things-factory/shell'
+import { KpiMetric } from '../kpi-metric/kpi-metric'
+
+/**
+ * KPI formula 파싱/검증/매핑 유효성 검사 서비스
+ * - formula에서 Metric 코드(변수명) 추출
+ * - 각 Metric의 존재/매핑 유효성 검사
+ * - 구문 오류, 미정의 Metric, 매핑 오류 등 에러 리포팅
+ */
+export class KpiFormulaService {
+  /**
+   * formula 문자열에서 Metric 코드(변수명) 추출
+   * @param formula KPI formula (예: 'defect_count / total_count * 100')
+   * @returns string[] 추출된 Metric 코드 리스트
+   */
+  extractMetricCodes(formula: string): string[] {
+    // 변수명: 알파벳/언더스코어로 시작, 숫자/알파벳/언더스코어 포함
+    const regex = /[a-zA-Z_][a-zA-Z0-9_]*/g
+    // 숫자/예약어/연산자 제외(후처리 필요)
+    const reserved = new Set(['if', 'else', 'return', 'true', 'false'])
+    return Array.from(new Set((formula.match(regex) || []).filter(code => isNaN(Number(code)) && !reserved.has(code))))
+  }
+
+  /**
+   * formula 내 Metric 코드의 존재/매핑 유효성 검사 + 순환참조 검출
+   * @param formula KPI formula
+   * @param visited 순환참조 검출용 Set (재귀 호출 시 사용)
+   * @returns { valid: boolean, errors: string[] }
+   */
+  async validateFormula(
+    formula: string,
+    visited: Set<string> = new Set()
+  ): Promise<{ valid: boolean; errors: string[] }> {
+    const errors: string[] = []
+    const metricCodes = this.extractMetricCodes(formula)
+    const metricRepo = getRepository(KpiMetric)
+    for (const code of metricCodes) {
+      if (visited.has(code)) {
+        errors.push(`순환참조 감지: ${Array.from(visited).join(' → ')} → ${code}`)
+        continue
+      }
+      visited.add(code)
+      const metric = await metricRepo.findOne({ where: { name: code } })
+      if (!metric) {
+        errors.push(`Metric '${code}' is not defined.`)
+        visited.delete(code)
+        continue
+      }
+      if (!metric.dataSetId || !metric.fieldName) {
+        errors.push(`Metric '${code}' is not mapped to a dataset field.`)
+      }
+      // metric이 formula를 가지고 있다면 재귀적으로 순환참조 검증
+      if ((metric as any).formula) {
+        const subResult = await this.validateFormula((metric as any).formula, new Set(visited))
+        if (!subResult.valid) errors.push(...subResult.errors)
+      }
+      visited.delete(code)
+    }
+    // (선택) formula 구문 오류, 괄호 불일치 등 추가 검사 가능
+    // ...
+    return { valid: errors.length === 0, errors }
+  }
+}

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

@@ -1,5 +1,5 @@
 import { Field, ID, ObjectType } from 'type-graphql'
-import { Column, Entity, Index, ManyToOne, PrimaryGeneratedColumn, RelationId } from 'typeorm'
+import { Column, Entity, Index, ManyToOne, PrimaryGeneratedColumn, RelationId, JoinColumn } from 'typeorm'
 
 import {
   HistoryActionColumn,
@@ -12,21 +12,16 @@ import { config } from '@things-factory/env'
 import { Domain } from '@things-factory/shell'
 
 import { Kpi, KpiStatus } from './kpi'
+import { KpiCategory } from '../kpi-category/kpi-category'
 
 const ORMCONFIG = config.get('ormconfig', {})
 const DATABASE_TYPE = ORMCONFIG.type
 
 @Entity()
-@Index(
-  'ix_kpi_history_0',
-  (kpiHistory: KpiHistory) => [kpiHistory.originalId, kpiHistory.version],
-  { unique: true }
-)
-@Index(
-  'ix_kpi_history_1',
-  (kpiHistory: KpiHistory) => [kpiHistory.domain, kpiHistory.originalId, kpiHistory.version],
-  { unique: true }
-)
+@Index('ix_kpi_history_0', (kpiHistory: KpiHistory) => [kpiHistory.originalId, kpiHistory.version], { unique: true })
+@Index('ix_kpi_history_1', (kpiHistory: KpiHistory) => [kpiHistory.domain, kpiHistory.originalId, kpiHistory.version], {
+  unique: true
+})
 @ObjectType({ description: 'History Entity of Kpi' })
 export class KpiHistory implements HistoryEntityInterface<Kpi> {
   @PrimaryGeneratedColumn('uuid')
@@ -52,17 +47,27 @@ 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 })
+  @Field({ nullable: true, description: 'Calculation formula for the KPI.' })
+  formula?: string
+
+  @Column({ nullable: false, default: false })
+  @Field({ nullable: true, description: 'Whether this KPI is active (usable) or not.' })
   active?: boolean
 
   @Column({ nullable: true })
-  @Field({ nullable: true })
+  @Field({ nullable: true, description: 'Current state of the KPI (DRAFT, RELEASED, ARCHIVED).' })
   state?: KpiStatus
 
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  params?: string
+  @Field(type => String, { nullable: true, description: 'Thumbnail image or file path for this KPI.' })
+  thumbnail?: string
 
   @Column({ nullable: true })
   @Field({ nullable: true })
@@ -90,12 +95,15 @@ export class KpiHistory implements HistoryEntityInterface<Kpi> {
   @RelationId((kpi: Kpi) => kpi.updater)
   updaterId?: string
 
-  @Field(type => String, { nullable: true })
-  thumbnail?: string
-
-  @HistoryOriginalIdColumn()
+  @HistoryOriginalIdColumn({ type: 'uuid' })
   public originalId!: string
 
+  // Kpi와의 릴레이션 추가 (originalId를 외래키로 사용)
+  @ManyToOne(() => Kpi, { nullable: false })
+  @JoinColumn({ name: 'originalId', referencedColumnName: 'id' })
+  @Field(type => Kpi, { nullable: false, description: '이 이력이 속한 KPI' })
+  kpi: Kpi
+
   @HistoryActionColumn({
     nullable: false,
     type:
@@ -110,7 +118,7 @@ export class KpiHistory implements HistoryEntityInterface<Kpi> {
       DATABASE_TYPE == 'postgres' || DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb'
         ? HistoryActionType
         : undefined,
-    length: DATABASE_TYPE == 'postgres' || DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb' ? undefined: 32
+    length: DATABASE_TYPE == 'postgres' || DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb' ? undefined : 32
   })
   public action!: HistoryActionType
 }