@things-factory/kpi 9.0.21 → 9.0.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/kpi",
-  "version": "9.0.21",
+  "version": "9.0.23",
   "main": "dist-server/index.js",
   "browser": "dist-client/index.js",
   "things-factory": true,
@@ -44,5 +44,5 @@
     "@things-factory/dataset": "^9.0.20",
     "@things-factory/shell": "^9.0.20"
   },
-  "gitHead": "0b142308f7695abe45d6e144d22e075bef5eda3d"
+  "gitHead": "3038f35d4e6f8d5e0f9384edfaca0c17104c6872"
 }

package/server/calculator/evaluator.ts

@@ -0,0 +1,45 @@
+import type { FormulaNode } from './parser'
+import type { FormulaFunctionMap } from './functions'
+import type { ValueProvider } from './provider'
+
+export interface EvalContext {
+  functions: FormulaFunctionMap
+  provider: ValueProvider
+}
+
+// 비동기 evaluator만 유지, 함수명은 evaluateFormula로 단순화
+export async function evaluateFormula(node: FormulaNode, ctx: EvalContext): Promise<any> {
+  switch (node.type) {
+    case 'number':
+      return node.value
+    case 'variable':
+      return await ctx.provider.get(node.name)
+    case 'function': {
+      const fn = ctx.functions[node.name]
+      if (!fn) throw new Error('Unknown function: ' + node.name)
+      const args = await Promise.all(node.args.map(arg => evaluateFormula(arg, ctx)))
+      return fn(...args)
+    }
+    case 'binary': {
+      const l = await evaluateFormula(node.left, ctx)
+      const r = await evaluateFormula(node.right, ctx)
+      switch (node.op) {
+        case '+':
+          return l + r
+        case '-':
+          return l - r
+        case '*':
+          return l * r
+        case '/':
+          return l / r
+        default:
+          throw new Error('Unknown operator: ' + node.op)
+      }
+    }
+    case 'unary':
+      if (node.op === '-') return -(await evaluateFormula(node.arg, ctx))
+      throw new Error('Unknown unary operator: ' + node.op)
+    default:
+      throw new Error('Unknown node type: ' + (node as any).type)
+  }
+}

package/server/calculator/functions.ts

@@ -0,0 +1,67 @@
+export type FormulaFunction = (...args: any[]) => any
+export type FormulaFunctionMap = Record<string, FormulaFunction>
+
+export const builtinFunctions: FormulaFunctionMap = {
+  sum: (...args: any[]) => args.reduce((a, b) => a + b, 0),
+  avg: (...args: any[]) => (args.length ? args.reduce((a, b) => a + b, 0) / args.length : 0),
+  min: (...args: any[]) => Math.min(...args),
+  max: (...args: any[]) => Math.max(...args),
+  round: (v: number, d: number = 0) => Number(v.toFixed(d)),
+  if: (cond: any, t: any, f: any) => (cond ? t : f),
+  // 성과 지수 계산을 위한 수치 적분 함수들
+  integrate: (func: Function, a: number, b: number, n: number = 1000) => {
+    // 사다리꼴 적분법 (Trapezoidal Rule)
+    const h = (b - a) / n
+    let sum = (func(a) + func(b)) / 2
+    for (let i = 1; i < n; i++) {
+      sum += func(a + i * h)
+    }
+    return sum * h
+  },
+
+  beta_integrand: (t: number, alpha: number, beta: number) => {
+    // 베타 분포 피적분함수: t^(α-1) × (1-t)^(β-1)
+    return Math.pow(t, alpha - 1) * Math.pow(1 - t, beta - 1)
+  },
+
+  incomplete_beta: (x: number, alpha: number, beta: number) => {
+    // 불완전 베타 함수 계산
+    const func = (t: number) => Math.pow(t, alpha - 1) * Math.pow(1 - t, beta - 1)
+    const h = x / 1000
+    let sum = (func(0) + func(x)) / 2
+    for (let i = 1; i < 1000; i++) {
+      sum += func(i * h)
+    }
+    return sum * h
+  },
+
+  complete_beta: (alpha: number, beta: number) => {
+    // 완전 베타 함수 계산
+    const func = (t: number) => Math.pow(t, alpha - 1) * Math.pow(1 - t, beta - 1)
+    const h = 1 / 1000
+    let sum = (func(0) + func(1)) / 2
+    for (let i = 1; i < 1000; i++) {
+      sum += func(i * h)
+    }
+    return sum * h
+  },
+
+  performance_index: (x: number, alpha1: number, beta1: number, alpha2: number, beta2: number) => {
+    // 성과 지수 계산: 1 - (불완전 베타 / 완전 베타)
+    const numerator = builtinFunctions.incomplete_beta(x, alpha1, beta1)
+    const denominator = builtinFunctions.complete_beta(alpha2, beta2)
+    return 1 - numerator / denominator
+  },
+
+  // 지수 함수들
+  exp: (x: number) => Math.exp(x),
+  log: (x: number) => Math.log(x),
+  pow: (x: number, y: number) => Math.pow(x, y),
+
+  // 지수 감쇠 성과 지수
+  exponential_decay: (value: number, scale: number, power: number) => {
+    // exp(-(value / scale)^power)
+    return Math.exp(-Math.pow(value / scale, power))
+  }
+  // 필요시 확장
+}

package/server/calculator/index.ts

@@ -0,0 +1,4 @@
+export * from './parser'
+export * from './evaluator'
+export * from './functions'
+export * from './provider'

package/server/calculator/parser.ts

@@ -0,0 +1,128 @@
+// KPI formula 파서: 수식 문자열을 AST로 변환
+
+export type FormulaNode =
+  | { type: 'number'; value: number }
+  | { type: 'variable'; name: string }
+  | { type: 'function'; name: string; args: FormulaNode[] }
+  | { type: 'binary'; op: string; left: FormulaNode; right: FormulaNode }
+  | { type: 'unary'; op: string; arg: FormulaNode }
+
+// 토큰 타입 정의
+const TOKEN_REGEX = /\s*(\d+\.\d+|\d+|\[.*?\]|[A-Za-z_][A-Za-z0-9_]*|[+\-*/(),])/y
+
+interface Token {
+  type: 'number' | 'variable' | 'function' | 'operator' | 'paren' | 'comma'
+  value: string
+}
+
+function tokenize(formula: string): Token[] {
+  const tokens: Token[] = []
+  let m: RegExpExecArray | null
+  let lastIndex = 0
+  while ((m = TOKEN_REGEX.exec(formula))) {
+    lastIndex = TOKEN_REGEX.lastIndex
+    const [raw] = m
+    if (/^\d/.test(raw)) {
+      tokens.push({ type: 'number', value: raw })
+    } else if (/^\[.*\]$/.test(raw)) {
+      tokens.push({ type: 'variable', value: raw.slice(1, -1) })
+    } else if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(raw)) {
+      tokens.push({ type: 'function', value: raw })
+    } else if (/^[+\-*/]$/.test(raw)) {
+      tokens.push({ type: 'operator', value: raw })
+    } else if (/^[(),]$/.test(raw)) {
+      if (raw === ',') tokens.push({ type: 'comma', value: raw })
+      else tokens.push({ type: 'paren', value: raw })
+    }
+  }
+  if (lastIndex < formula.length) {
+    throw new Error('Unexpected token at: ' + formula.slice(lastIndex))
+  }
+  return tokens
+}
+
+// 파서 구현 (재귀 하향, 연산자 우선순위, 함수/변수/숫자/괄호 지원)
+export function parseFormula(formula: string): FormulaNode {
+  const tokens = tokenize(formula)
+  let pos = 0
+
+  function peek() {
+    return tokens[pos]
+  }
+  function next() {
+    return tokens[pos++]
+  }
+  function expect(type: string, value?: string) {
+    const t = next()
+    if (!t || t.type !== type || (value && t.value !== value))
+      throw new Error('Expected ' + type + (value ? ':' + value : ''))
+    return t
+  }
+
+  function parsePrimary(): FormulaNode {
+    const t = peek()
+    if (!t) throw new Error('Unexpected end')
+    if (t.type === 'number') {
+      next()
+      return { type: 'number', value: parseFloat(t.value) }
+    }
+    if (t.type === 'variable') {
+      next()
+      return { type: 'variable', name: t.value }
+    }
+    if (t.type === 'function') {
+      // 함수 호출: func(expr, ...)
+      const name = t.value
+      next()
+      expect('paren', '(')
+      const args: FormulaNode[] = []
+      if ((peek() && peek().type !== 'paren') || (peek() && peek().value !== ')')) {
+        while (true) {
+          args.push(parseExpr())
+          if (peek() && peek().type === 'comma') {
+            next()
+          } else break
+        }
+      }
+      expect('paren', ')')
+      return { type: 'function', name, args }
+    }
+    if (t.type === 'operator' && t.value === '-') {
+      next()
+      return { type: 'unary', op: '-', arg: parsePrimary() }
+    }
+    if (t.type === 'paren' && t.value === '(') {
+      next()
+      const node = parseExpr()
+      expect('paren', ')')
+      return node
+    }
+    throw new Error('Unexpected token: ' + t.type + ':' + t.value)
+  }
+
+  function parseMulDiv(): FormulaNode {
+    let node = parsePrimary()
+    while (peek() && peek().type === 'operator' && (peek().value === '*' || peek().value === '/')) {
+      const op = next().value
+      node = { type: 'binary', op, left: node, right: parsePrimary() }
+    }
+    return node
+  }
+
+  function parseAddSub(): FormulaNode {
+    let node = parseMulDiv()
+    while (peek() && peek().type === 'operator' && (peek().value === '+' || peek().value === '-')) {
+      const op = next().value
+      node = { type: 'binary', op, left: node, right: parseMulDiv() }
+    }
+    return node
+  }
+
+  function parseExpr(): FormulaNode {
+    return parseAddSub()
+  }
+
+  const ast = parseExpr()
+  if (pos < tokens.length) throw new Error('Unexpected token at end: ' + JSON.stringify(tokens[pos]))
+  return ast
+}

package/server/calculator/provider.ts

@@ -0,0 +1,10 @@
+export interface ValueProvider {
+  get(name: string): any | Promise<any>
+}
+
+export class ObjectValueProvider implements ValueProvider {
+  constructor(private values: Record<string, any>) {}
+  get(name: string) {
+    return this.values[name]
+  }
+}

package/server/controllers/kpi-metric-value-provider.ts

@@ -0,0 +1,66 @@
+import { getRepository } from '@things-factory/shell'
+import { KpiMetric } from '../service/kpi-metric/kpi-metric'
+import { KpiMetricValue } from '../service/kpi-metric-value/kpi-metric-value'
+import { ValueProvider } from '../calculator/provider'
+import { getDefaultValueDate } from '../service/utils/value-date-util'
+
+export class KpiMetricValueProvider implements ValueProvider {
+  constructor(
+    private options: {
+      valueDate: string
+      group?: string
+      domainId: string
+      tx?: any
+    }
+  ) {}
+
+  async get(name: string) {
+    const metricRepo = getRepository(KpiMetric, this.options.tx)
+    const metric = await metricRepo.findOne({ where: { name, domain: { id: this.options.domainId } } })
+    if (!metric) throw new Error(`Metric not found: ${name}`)
+
+    // ALLTIME 타입인 경우 valueDate 무시하고 최신 값 조회
+    if (metric.periodType === 'ALLTIME') {
+      const valueRepo = getRepository(KpiMetricValue, this.options.tx)
+      const value = await valueRepo.findOne({
+        where: {
+          metric: { id: metric.id },
+          group: this.options.group ?? '',
+          domain: { id: this.options.domainId }
+        },
+        order: { createdAt: 'DESC' }
+      })
+      if (!value) {
+        throw new Error(`Metric value not found: metric='${name}', group='${this.options.group ?? ''}' (ALLTIME type)`)
+      }
+      return value.value
+    }
+
+    // metric의 periodType에 맞게 valueDate 보정
+    let valueDate = this.options.valueDate
+    if (!valueDate) {
+      valueDate = getDefaultValueDate(metric.periodType, 'current')
+    } else {
+      // valueDate가 metric.periodType에 맞는 포맷인지 검사, 아니면 보정
+      // (간단히: 길이로 구분, 실제는 정규식 등으로 더 정교하게 가능)
+      if (metric.periodType === 'MONTH' && valueDate.length > 7) valueDate = valueDate.slice(0, 7)
+      if (metric.periodType === 'DAY' && valueDate.length > 10) valueDate = valueDate.slice(0, 10)
+      // 기타 periodType별 보정 추가 가능
+    }
+    const valueRepo = getRepository(KpiMetricValue, this.options.tx)
+    const value = await valueRepo.findOne({
+      where: {
+        metric: { id: metric.id },
+        valueDate,
+        group: this.options.group ?? '',
+        domain: { id: this.options.domainId }
+      }
+    })
+    if (!value) {
+      throw new Error(
+        `Metric value not found: metric='${name}', group='${this.options.group ?? ''}', valueDate='${valueDate}', periodType='${metric.periodType}'`
+      )
+    }
+    return value.value
+  }
+}

package/server/controllers/kpi-value-provider.ts

@@ -0,0 +1,51 @@
+import { getRepository } from '@things-factory/shell'
+import { Kpi } from '../service/kpi/kpi'
+import { KpiValue } from '../service/kpi-value/kpi-value'
+import { ValueProvider } from '../calculator/provider'
+
+export class KpiValueProvider implements ValueProvider {
+  constructor(
+    private options: {
+      valueDate: string
+      group?: string
+      domainId: string
+      tx?: any
+    }
+  ) {}
+
+  async get(name: string) {
+    const kpiRepo = getRepository(Kpi, this.options.tx)
+    const kpi = await kpiRepo.findOne({ where: { name, domain: { id: this.options.domainId } } })
+    if (!kpi) throw new Error(`KPI not found: ${name}`)
+    const valueRepo = getRepository(KpiValue, this.options.tx)
+
+    // SINGLE 타입인 경우 valueDate 무시하고 최신 값 조회
+    const whereCondition: any = {
+      kpi: { id: kpi.id },
+      group: this.options.group ?? '',
+      domain: { id: this.options.domainId }
+    }
+
+    if (kpi.periodType === 'ALLTIME') {
+      // ALLTIME 타입은 valueDate 무시하고 최신 값 사용
+      const value = await valueRepo.findOne({
+        where: whereCondition,
+        order: { createdAt: 'DESC' }
+      })
+      if (!value) {
+        throw new Error(`KPI value not found: kpi='${name}', group='${this.options.group ?? ''}' (ALLTIME type)`)
+      }
+      return value.value
+    } else {
+      // 기존 로직: 특정 날짜의 값 조회
+      whereCondition.valueDate = this.options.valueDate
+      const value = await valueRepo.findOne({ where: whereCondition })
+      if (!value) {
+        throw new Error(
+          `KPI value not found: kpi='${name}', group='${this.options.group ?? ''}', valueDate='${this.options.valueDate}'`
+        )
+      }
+      return value.value
+    }
+  }
+}

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

@@ -4,7 +4,7 @@ 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'
-import { KpiValueGradeService } from '../kpi-value/kpi-value-grade.service'
+import { KpiValueScoreService } from '../kpi-value/kpi-value-score.service'
 
 /**
  * KPI 단위 집계/산식 자동화 함수
@@ -15,7 +15,7 @@ import { KpiValueGradeService } from '../kpi-value/kpi-value-grade.service'
  */
 export async function aggregateKpiValue(kpiId: string, domainId: string, context: ResolverContext) {
   const tx = context.state?.tx || getRepository(Kpi).manager
-  const gradeService = new KpiValueGradeService()
+  const scoreService = new KpiValueScoreService()
 
   // 1. KPI 정보 조회
   const kpi = await getRepository(Kpi).findOne({ where: { id: kpiId, domain: { id: domainId } } })
@@ -75,8 +75,8 @@ export async function aggregateKpiValue(kpiId: string, domainId: string, context
     entity.creator = context.state?.user
     entity.updater = context.state?.user
 
-    // 등급 자동 계산 및 저장
-    await gradeService.calculateAndSaveGrade(entity, kpi)
+    // 성과 점수 자동 계산 및 저장
+    await scoreService.calculateAndSaveScore(entity, kpi)
 
     entity = await repo.save(entity)
     savedValues.push(entity)

package/server/service/kpi/kpi-grade.types.ts

@@ -1,27 +1,28 @@
 /**
- * KPI 등급 설정 타입 정의
+ * KPI 성과 점수 lookup table 타입 정의
+ * 복잡한 성과 점수 변환을 수식으로 표현하기 어려운 경우 사용
  */
-export interface KpiGrade {
-  /** 등급명 (예: A, B, C, 우수, 양호 등) */
+export interface KpiScore {
+  /** 성과 지수명 (예: A, B, C, 우수, 양호 등) */
   name: string
 
-  /** 등급의 최소값 */
+  /** 성과 점수 변환 기준 최소값 */
   minValue: number
 
-  /** 등급의 최대값 */
+  /** 성과 점수 변환 기준 최대값 */
   maxValue: number
 
-  /** 등급 점수 (선택사항) */
+  /** 성과 지수 점수 (선택사항) */
   score?: number
 
-  /** 등급 색상 (선택사항) */
+  /** 성과 지수 색상 (선택사항) */
   color?: string
 
-  /** 등급 설명 (선택사항) */
+  /** 성과 지수 설명 (선택사항) */
   description?: string
 }
 
 /**
- * KPI 등급 배열 타입
+ * KPI 성과 점수 lookup table 배열 타입
  */
-export type KpiGrades = KpiGrade[]
+export type KpiScores = KpiScore[]

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

@@ -13,7 +13,7 @@ import { Domain, ScalarObject } from '@things-factory/shell'
 
 import { Kpi, KpiStatus, KpiPeriodType } from './kpi'
 import { KpiCategory } from '../kpi-category/kpi-category'
-import { KpiGrades } from './kpi-grade.types'
+import { KpiScores } from './kpi-grade.types'
 
 const ORMCONFIG = config.get('ormconfig', {})
 const DATABASE_TYPE = ORMCONFIG.type
@@ -75,7 +75,7 @@ export class KpiHistory implements HistoryEntityInterface<Kpi> {
     nullable: true,
     description: 'Grade configuration for this KPI version'
   })
-  grades?: KpiGrades
+  grades?: KpiScores
 
   @Column({ type: 'float', nullable: true, default: 1 })
   @Field({ nullable: true, description: 'Weight for aggregation in parent category.' })

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

@@ -9,6 +9,14 @@ 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 { Between } from 'typeorm'
+import { KpiMetric } from '../kpi-metric/kpi-metric'
+import { KpiMetricValue } from '../kpi-metric-value/kpi-metric-value'
+import { parseFormula } from '../../calculator/parser'
+import { evaluateFormula } from '../../calculator/evaluator'
+import { builtinFunctions } from '../../calculator/functions'
+import { KpiMetricValueProvider } from '../../controllers/kpi-metric-value-provider'
 
 @Resolver(Kpi)
 export class KpiMutation {
@@ -20,8 +28,8 @@ export class KpiMutation {
   ): Promise<Kpi> {
     const { domain, user, tx } = context.state
 
-    let category = kpi.categoryId
-      ? await getRepository(KpiCategory).findOne({ where: { id: kpi.categoryId } })
+    let category = kpi.category
+      ? await getRepository(KpiCategory).findOne({ where: { id: kpi.category.id } })
       : undefined
 
     const result = await getRepository(Kpi, tx).save({
@@ -104,8 +112,8 @@ export class KpiMutation {
       where: { domain: { id: domain.id }, id }
     })
 
-    let category = patch.categoryId
-      ? await getRepository(KpiCategory).findOne({ where: { id: patch.categoryId } })
+    let category = patch.category
+      ? await getRepository(KpiCategory).findOne({ where: { id: patch.category.id } })
       : kpi.category
 
     const result = await repository.save({
@@ -377,4 +385,120 @@ export class KpiMutation {
     } as any)
     return updated
   }
+
+  @Directive('@transaction')
+  @Mutation(returns => KpiValue, { description: 'KPI 기준으로 formula 계산 및 KPI Value upsert' })
+  async calculateKpiValue(
+    @Arg('kpiId') kpiId: string,
+    @Arg('valueDate', { nullable: true }) valueDate: string,
+    @Arg('group', { nullable: true }) group: string,
+    @Ctx() context: ResolverContext
+  ): Promise<KpiValue> {
+    const { domain, user, tx } = context.state
+    const kpiRepo = getRepository(Kpi, tx)
+    const metricRepo = getRepository<KpiMetric>(require('../kpi-metric/kpi-metric').KpiMetric, tx)
+    const metricValueRepo = getRepository<KpiMetricValue>(
+      require('../kpi-metric-value/kpi-metric-value').KpiMetricValue,
+      tx
+    )
+    const kpiValueRepo = getRepository<KpiValue>(KpiValue, tx)
+    const { KpiPeriodType } = require('./kpi')
+    const { getDefaultValueDate } = require('../utils/value-date-util')
+
+    // 1. KPI 정보 조회
+    const kpi = await kpiRepo.findOne({ where: { id: kpiId, domain: { id: domain.id } } })
+    if (!kpi) throw new Error('KPI 정보 없음')
+    if (!kpi.formula) throw new Error('KPI formula 없음')
+    const periodType = kpi.periodType || KpiPeriodType.DAY
+    const valueDateToUse = valueDate || getDefaultValueDate(periodType, 'last')
+
+    // 2. formula에서 metric code 추출
+    const metricCodes = (kpi.formula.match(/[a-zA-Z_][a-zA-Z0-9_]*/g) || []).filter(
+      code => code !== 'null' && code !== 'undefined'
+    )
+    const metricMap: Record<string, any> = {}
+    for (const code of metricCodes) {
+      const metric = await metricRepo.findOne({ where: { name: code, domain: { id: domain.id } } })
+      if (!metric) throw new Error(`KPI formula metric '${code}' not found`)
+      metricMap[code] = metric
+    }
+
+    // 3. metric 값 집계 (periodType 변환/집계)
+    const metricValues: Record<string, number> = {}
+    for (const code of metricCodes) {
+      const metric = metricMap[code]
+      let value = null
+      if (metric.periodType === periodType) {
+        const mv = await metricValueRepo.findOne({
+          where: {
+            metric: { id: metric.id },
+            valueDate: valueDateToUse,
+            periodType,
+            group: group ?? '',
+            domain: { id: domain.id }
+          }
+        })
+        value = mv?.value ?? null
+      } else {
+        let startDate: string, endDate: string
+        if (periodType === KpiPeriodType.MONTH && metric.periodType === KpiPeriodType.DAY) {
+          startDate = valueDateToUse + '-01'
+          endDate = valueDateToUse + '-31'
+          const mvs = await metricValueRepo.find({
+            where: {
+              metric: { id: metric.id },
+              valueDate: Between(startDate, endDate),
+              periodType: metric.periodType,
+              group: group ?? '',
+              domain: { id: domain.id }
+            }
+          })
+          value = mvs.reduce((sum, mv) => sum + (mv.value ?? 0), 0)
+        } else {
+          throw new Error('KPI/Metric periodType 조합 집계 미지원')
+        }
+      }
+      if (value == null) throw new Error(`Metric '${code}' 값 없음`)
+      metricValues[code] = value
+    }
+
+    // 4. formula 계산 (calculator 기반)
+    const ast = parseFormula(kpi.formula)
+    const provider = new KpiMetricValueProvider({
+      valueDate: valueDateToUse,
+      group,
+      domainId: domain.id,
+      tx
+    })
+    const evalContext = { functions: builtinFunctions, provider }
+    const kpiValueResult = await evaluateFormula(ast, evalContext)
+
+    // 5. KPI Value upsert
+    let kpiValue = await kpiValueRepo.findOne({
+      where: {
+        kpi: { id: kpi.id },
+        valueDate: valueDateToUse,
+        group: group ?? '',
+        version: kpi.version,
+        domain: { id: domain.id }
+      }
+    })
+    if (kpiValue) {
+      kpiValue.value = kpiValueResult
+      kpiValue.updater = user
+    } else {
+      kpiValue = kpiValueRepo.create({
+        kpi,
+        kpiId: kpi.id,
+        version: kpi.version,
+        valueDate: valueDateToUse,
+        value: kpiValueResult,
+        group: group ?? '',
+        domain,
+        creator: user,
+        updater: user
+      })
+    }
+    return await kpiValueRepo.save(kpiValue)
+  }
 }