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

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

@@ -0,0 +1,59 @@
+import { Resolver, Query, Ctx } from 'type-graphql'
+import { getRepository } from '@things-factory/shell'
+import { Kpi } from '../kpi/kpi'
+import { KpiValue } from '../kpi-value/kpi-value'
+import { KpiGrade } from '../kpi-grade/kpi-grade'
+import { KpiAlert } from './kpi-alert-type'
+
+@Resolver()
+export class KpiAlertQuery {
+  @Query(returns => [KpiAlert], { description: 'KPI 실적/등급/목표 미달 등 경고/알림 리스트 반환' })
+  async kpiAlerts(@Ctx() context): Promise<KpiAlert[]> {
+    const { domain } = context.state
+    // 1. KPI 전체 조회
+    const kpis = await getRepository(Kpi).find({ where: { domain: { id: domain.id } }, relations: ['grades'] })
+    // 2. KPI별 최신 실적값 조회
+    const alerts: KpiAlert[] = []
+    for (const kpi of kpis) {
+      const value = await getRepository(KpiValue).findOne({
+        where: { domain: { id: domain.id }, kpi: { id: kpi.id } },
+        order: { valueDate: 'DESC' }
+      })
+      if (!value) {
+        alerts.push({
+          id: `${kpi.id}-no-value`,
+          kpi,
+          message: `${kpi.name} 실적값 미입력`,
+          level: 'info',
+          createdAt: new Date()
+        })
+        continue
+      }
+      // 목표값(예: kpi.vizMeta?.targetValue) 기준 경고
+      const target = kpi.vizMeta?.targetValue
+      if (target !== undefined && value.value < target) {
+        alerts.push({
+          id: `${kpi.id}-target-miss`,
+          kpi,
+          message: `${kpi.name} 실적(${value.value})이 목표(${target}) 미달`,
+          level: 'warning',
+          createdAt: new Date()
+        })
+      }
+      // 등급 기준 경고(예: 최하위 등급)
+      if (kpi.grades?.length) {
+        const grade = kpi.grades.find(g => value.value >= g.minValue && value.value <= g.maxValue)
+        if (grade && grade.score !== undefined && grade.score <= 2) {
+          alerts.push({
+            id: `${kpi.id}-grade-low`,
+            kpi,
+            message: `${kpi.name} 등급(${grade.name})(${grade.score}점)`,
+            level: 'critical',
+            createdAt: new Date()
+          })
+        }
+      }
+    }
+    return alerts
+  }
+}

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

@@ -0,0 +1,20 @@
+import { ObjectType, Field, ID } from 'type-graphql'
+import { Kpi } from '../kpi/kpi'
+
+@ObjectType({ description: 'KPI 경고/알림 엔티티. KPI 실적, 등급, 목표 미달 등 경고/알림 정보를 제공.' })
+export class KpiAlert {
+  @Field(type => ID)
+  id: string
+
+  @Field(type => Kpi, { nullable: true, description: '경고/알림이 발생한 KPI.' })
+  kpi?: Kpi
+
+  @Field({ description: '경고/알림 메시지.' })
+  message: string
+
+  @Field({ description: '경고 레벨(예: warning, critical, info 등).' })
+  level: string
+
+  @Field({ description: '경고/알림 발생 시각.' })
+  createdAt: Date
+}

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

@@ -8,12 +8,21 @@ import { NewKpiCategory, KpiCategoryPatch } from './kpi-category-type'
 @Resolver(KpiCategory)
 export class KpiCategoryMutation {
   @Directive('@transaction')
-  @Mutation(returns => KpiCategory, { description: 'To create new KpiCategory' })
-  async createKpiCategory(@Arg('kpiCategory') kpiCategory: NewKpiCategory, @Ctx() context: ResolverContext): Promise<KpiCategory> {
+  @Mutation(returns => KpiCategory, { description: 'Create a new KPI category with the provided details.' })
+  async createKpiCategory(
+    @Arg('category', { description: 'Input object containing details for the new KPI category.' })
+    category: NewKpiCategory,
+    @Ctx() context: ResolverContext
+  ): Promise<KpiCategory> {
     const { domain, user, tx } = context.state
 
+    let parent = category.parentId
+      ? await getRepository(KpiCategory).findOne({ where: { id: category.parentId } })
+      : undefined
+
     const result = await getRepository(KpiCategory, tx).save({
-      ...kpiCategory,
+      ...category,
+      parent,
       domain,
       creator: user,
       updater: user
@@ -36,9 +45,14 @@ export class KpiCategoryMutation {
       where: { domain: { id: domain.id }, id }
     })
 
+    let parent = patch.parentId
+      ? await getRepository(KpiCategory).findOne({ where: { id: patch.parentId } })
+      : kpiCategory.parent
+
     const result = await repository.save({
       ...kpiCategory,
       ...patch,
+      parent,
       updater: user
     })
 
@@ -114,7 +128,6 @@ export class KpiCategoryMutation {
       id: In(ids)
     })
 
-
     return true
   }
 

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

@@ -3,11 +3,18 @@ import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from
 import { User } from '@things-factory/auth-base'
 import { KpiCategory } from './kpi-category'
 import { KpiCategoryList } from './kpi-category-type'
+import { Kpi } from '../kpi/kpi'
 
 @Resolver(KpiCategory)
 export class KpiCategoryQuery {
-  @Query(returns => KpiCategory!, { nullable: true, description: 'To fetch a KpiCategory' })
-  async kpiCategory(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<KpiCategory> {
+  @Query(returns => KpiCategory!, {
+    nullable: true,
+    description: 'Fetch a single KPI category by its unique identifier.'
+  })
+  async kpiCategory(
+    @Arg('id', { description: 'Unique identifier of the KPI category to fetch.' }) id: string,
+    @Ctx() context: ResolverContext
+  ): Promise<KpiCategory> {
     const { domain } = context.state
 
     return await getRepository(KpiCategory).findOne({
@@ -16,7 +23,10 @@ export class KpiCategoryQuery {
   }
 
   @Query(returns => KpiCategoryList, { description: 'To fetch multiple KpiCategories' })
-  async kpiCategories(@Args(type => ListParam) params: ListParam, @Ctx() context: ResolverContext): Promise<KpiCategoryList> {
+  async kpiCategories(
+    @Args(type => ListParam) params: ListParam,
+    @Ctx() context: ResolverContext
+  ): Promise<KpiCategoryList> {
     const { domain } = context.state
 
     const queryBuilder = getQueryBuilderFromListParams({
@@ -31,6 +41,13 @@ export class KpiCategoryQuery {
     return { items, total }
   }
 
+  @FieldResolver(type => [Kpi])
+  async kpis(@Root() kpiCategory: KpiCategory): Promise<Kpi[]> {
+    return await getRepository(Kpi).find({
+      where: { domain: { id: kpiCategory.domainId }, category: { id: kpiCategory.id } }
+    })
+  }
+
   @FieldResolver(type => Domain)
   async domain(@Root() kpiCategory: KpiCategory): Promise<Domain> {
     return kpiCategory.domainId && (await getRepository(Domain).findOneBy({ id: kpiCategory.domainId }))

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

@@ -4,44 +4,42 @@ import { ObjectType, Field, InputType, Int, ID, registerEnumType } from 'type-gr
 
 import { ObjectRef, ScalarObject } from '@things-factory/shell'
 
-import { KpiCategory, KpiCategoryStatus } from './kpi-category'
+import { KpiCategory } from './kpi-category'
 
-@InputType()
+@InputType({
+  description: 'Input type for creating a new KPI category. Used in mutations to provide category details.'
+})
 export class NewKpiCategory {
-  @Field()
+  @Field({ description: 'Name of the KPI category.' })
   name: string
 
-  @Field({ nullable: true })
+  @Field({ nullable: true, description: 'Detailed description of this KPI category.' })
   description?: string
 
-  @Field(type => KpiCategoryStatus, { nullable: true })
-  state?: KpiCategoryStatus
+  @Field(type => ID, { nullable: true, description: 'ID of the parent category, if any.' })
+  parentId?: string
 
   @Field({ nullable: true })
   active?: boolean
-
-  @Field({ nullable: true })
-  params?: string
 }
 
-@InputType()
+@InputType({
+  description: 'Input type for updating an existing KPI category. Used in mutations to patch category details.'
+})
 export class KpiCategoryPatch {
-  @Field(type => ID, { nullable: true })
+  @Field(type => ID, { nullable: true, description: 'ID of the KPI category to update.' })
   id?: string
 
-  @Field({ nullable: true })
+  @Field({ nullable: true, description: 'Name of the KPI category.' })
   name?: string
 
-  @Field({ nullable: true })
+  @Field({ nullable: true, description: 'Detailed description of this KPI category.' })
   description?: string
 
-  @Field(type => KpiCategoryStatus, { nullable: true })
-  state?: KpiCategoryStatus
+  @Field(type => ID, { nullable: true, description: 'ID of the parent category, if any.' })
+  parentId?: string
 
-  @Field({ nullable: true })
-  active?: boolean
-  
-  @Field({ nullable: true })
+  @Field({ nullable: true, description: 'Custom flag for update operations (internal use).' })
   cuFlag?: string
 }
 

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

@@ -6,79 +6,81 @@ import {
   Column,
   RelationId,
   ManyToOne,
+  OneToMany,
   PrimaryGeneratedColumn
 } from 'typeorm'
-import { ObjectType, Field, Int, ID, registerEnumType } from 'type-graphql'
+import { ObjectType, Field, Int, ID } from 'type-graphql'
 
 import { Domain } from '@things-factory/shell'
 import { User } from '@things-factory/auth-base'
-
-export enum KpiCategoryStatus {
-  STATUS_A = 'STATUS_A',
-  STATUS_B = 'STATUS_B'
-}
-
-registerEnumType(KpiCategoryStatus, {
-  name: 'KpiCategoryStatus',
-  description: 'state enumeration of a kpiCategory'
-})
+import { Kpi } from '../kpi/kpi'
 
 @Entity()
 @Index('ix_kpi_category_0', (kpiCategory: KpiCategory) => [kpiCategory.domain, kpiCategory.name], {
   unique: true
 })
-@ObjectType({ description: 'Entity for KpiCategory' })
+@ObjectType({
+  description:
+    'KPI category entity. Represents a classification or group for KPIs. Supports hierarchical (tree) structure.'
+})
 export class KpiCategory {
   @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
+  @Field(type => ID, { description: 'Unique identifier for this KPI category.' })
   readonly id: string
 
   @ManyToOne(type => Domain)
-  @Field({ nullable: true })
+  @Field({ nullable: true, description: 'Domain (tenant) to which this KPI category belongs.' })
   domain?: Domain
 
-  @RelationId((kpiCategory: KpiCategory) => kpiCategory.domain)
+  @RelationId((category: KpiCategory) => category.domain)
+  @Field({ nullable: true, description: 'ID of the domain (tenant) for this KPI category.' })
   domainId?: string
 
   @Column()
-  @Field({ nullable: true })
-  name?: string
+  @Field({ description: 'Name of the KPI category.' })
+  name: string
 
   @Column({ nullable: true })
-  @Field({ nullable: true })
+  @Field({ nullable: true, description: 'Detailed description of this KPI category.' })
   description?: string
 
   @Column({ nullable: false, default: false })
-  @Field({ nullable: true })
+  @Field({ nullable: true, description: 'Whether this category is active (usable) or not.' })
   active?: boolean
 
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  state?: KpiCategoryStatus
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  params?: string
-
-  @CreateDateColumn()
-  @Field({ nullable: true })
-  createdAt?: Date
+  @ManyToOne(type => KpiCategory, { nullable: true })
+  @Field(type => KpiCategory, { nullable: true, description: 'Parent category for hierarchical category structure.' })
+  parent?: KpiCategory
 
-  @UpdateDateColumn()
-  @Field({ nullable: true })
-  updatedAt?: Date
+  @RelationId((category: KpiCategory) => category.parent)
+  @Field({ nullable: true, description: 'ID of the parent category, if any.' })
+  parentId?: string
 
   @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
+  @Field(type => User, { nullable: true, description: 'User who created this KPI category.' })
   creator?: User
 
-  @RelationId((kpiCategory: KpiCategory) => kpiCategory.creator)
+  @RelationId((category: KpiCategory) => category.creator)
+  @Field({ nullable: true, description: 'ID of the user who created this KPI category.' })
   creatorId?: string
 
   @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
+  @Field(type => User, { nullable: true, description: 'User who last updated this KPI category.' })
   updater?: User
 
-  @RelationId((kpiCategory: KpiCategory) => kpiCategory.updater)
+  @RelationId((category: KpiCategory) => category.updater)
+  @Field({ nullable: true, description: 'ID of the user who last updated this KPI category.' })
   updaterId?: string
+
+  @CreateDateColumn()
+  @Field({ nullable: true, description: 'Timestamp when this KPI category was created.' })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true, description: 'Timestamp when this KPI category was last updated.' })
+  updatedAt?: Date
+
+  @OneToMany(type => Kpi, kpi => kpi.category)
+  @Field(type => [Kpi], { nullable: true, description: 'List of KPIs belonging to this category.' })
+  kpis?: Kpi[]
 }

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

@@ -1,9 +1,7 @@
 import { KpiGrade } from './kpi-grade'
-import { KpiGradeHistory } from './kpi-grade-history'
-import { KpiGradeHistoryEntitySubscriber } from './event-subscriber'
 import { KpiGradeQuery } from './kpi-grade-query'
 import { KpiGradeMutation } from './kpi-grade-mutation'
 
-export const entities = [KpiGrade, KpiGradeHistory]
+export const entities = [KpiGrade]
 export const resolvers = [KpiGradeQuery, KpiGradeMutation]
-export const subscribers = [KpiGradeHistoryEntitySubscriber]
+export const subscribers = []

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

@@ -4,16 +4,23 @@ import { getRepository } from '@things-factory/shell'
 
 import { KpiGrade } from './kpi-grade'
 import { NewKpiGrade, KpiGradePatch } from './kpi-grade-type'
+import { Kpi } from '../kpi/kpi'
 
 @Resolver(KpiGrade)
 export class KpiGradeMutation {
   @Directive('@transaction')
-  @Mutation(returns => KpiGrade, { description: 'To create new KpiGrade' })
-  async createKpiGrade(@Arg('kpiGrade') kpiGrade: NewKpiGrade, @Ctx() context: ResolverContext): Promise<KpiGrade> {
+  @Mutation(returns => KpiGrade, { description: 'Create a new KPI grade with the provided details.' })
+  async createKpiGrade(
+    @Arg('grade', { description: 'Input object containing details for the new KPI grade.' }) grade: NewKpiGrade,
+    @Ctx() context: ResolverContext
+  ): Promise<KpiGrade> {
     const { domain, user, tx } = context.state
 
+    let kpi = grade.kpiId ? await getRepository(Kpi).findOne({ where: { id: grade.kpiId } }) : undefined
+
     const result = await getRepository(KpiGrade, tx).save({
-      ...kpiGrade,
+      ...grade,
+      kpi,
       domain,
       creator: user,
       updater: user
@@ -36,9 +43,12 @@ export class KpiGradeMutation {
       where: { domain: { id: domain.id }, id }
     })
 
+    let kpi = patch.kpiId ? await getRepository(Kpi).findOne({ where: { id: patch.kpiId } }) : kpiGrade.kpi
+
     const result = await repository.save({
       ...kpiGrade,
       ...patch,
+      kpi,
       updater: user
     })
 
@@ -114,7 +124,6 @@ export class KpiGradeMutation {
       id: In(ids)
     })
 
-
     return true
   }
 

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

@@ -6,8 +6,11 @@ import { KpiGradeList } from './kpi-grade-type'
 
 @Resolver(KpiGrade)
 export class KpiGradeQuery {
-  @Query(returns => KpiGrade!, { nullable: true, description: 'To fetch a KpiGrade' })
-  async kpiGrade(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<KpiGrade> {
+  @Query(returns => KpiGrade!, { nullable: true, description: 'Fetch a single KPI grade by its unique identifier.' })
+  async kpiGrade(
+    @Arg('id', { description: 'Unique identifier of the KPI grade to fetch.' }) id: string,
+    @Ctx() context: ResolverContext
+  ): Promise<KpiGrade> {
     const { domain } = context.state
 
     return await getRepository(KpiGrade).findOne({

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

@@ -4,44 +4,71 @@ import { ObjectType, Field, InputType, Int, ID, registerEnumType } from 'type-gr
 
 import { ObjectRef, ScalarObject } from '@things-factory/shell'
 
-import { KpiGrade, KpiGradeStatus } from './kpi-grade'
+import { KpiGrade } from './kpi-grade'
 
-@InputType()
+@InputType({ description: 'Input type for creating a new KPI grade. Used in mutations to provide grade details.' })
 export class NewKpiGrade {
-  @Field()
+  @Field({ description: 'Name of the grade or section for this KPI.' })
   name: string
 
-  @Field({ nullable: true })
+  @Field({ nullable: true, description: 'Detailed description of this KPI grade.' })
   description?: string
 
-  @Field(type => KpiGradeStatus, { nullable: true })
-  state?: KpiGradeStatus
+  @Field(type => ID, { description: 'ID of the KPI to which this grade belongs.' })
+  kpiId: string
 
-  @Field({ nullable: true })
-  active?: boolean
+  @Field(type => Int, { description: 'Version of the KPI definition to which this grade belongs.' })
+  version: number
+
+  @Field(type => Int, { description: 'Minimum value for this grade section.' })
+  minValue: number
+
+  @Field(type => Int, { description: 'Maximum value for this grade section.' })
+  maxValue: number
 
-  @Field({ nullable: true })
-  params?: string
+  @Field(type => Int, { nullable: true, description: 'Score or weight for this grade (optional).' })
+  score?: number
+
+  @Field({ nullable: true, description: 'Color code for this grade (for visualization purposes).' })
+  color?: string
+
+  @Field({ nullable: true, description: 'Indicates whether this KPI grade is active and usable.' })
+  active?: boolean
 }
 
-@InputType()
+@InputType({ description: 'Input type for updating an existing KPI grade. Used in mutations to patch grade details.' })
 export class KpiGradePatch {
-  @Field(type => ID, { nullable: true })
+  @Field(type => ID, { nullable: true, description: 'ID of the KPI grade to update.' })
   id?: string
 
-  @Field({ nullable: true })
+  @Field({ nullable: true, description: 'Name of the grade or section for this KPI.' })
   name?: string
 
-  @Field({ nullable: true })
+  @Field({ nullable: true, description: 'Detailed description of this KPI grade.' })
   description?: string
 
-  @Field(type => KpiGradeStatus, { nullable: true })
-  state?: KpiGradeStatus
+  @Field(type => ID, { nullable: true, description: 'ID of the KPI to which this grade belongs.' })
+  kpiId?: string
 
-  @Field({ nullable: true })
+  @Field(type => Int, { nullable: true, description: 'Version of the KPI definition to which this grade belongs.' })
+  version?: number
+
+  @Field(type => Int, { nullable: true, description: 'Minimum value for this grade section.' })
+  minValue?: number
+
+  @Field(type => Int, { nullable: true, description: 'Maximum value for this grade section.' })
+  maxValue?: number
+
+  @Field(type => Int, { nullable: true, description: 'Score or weight for this grade (optional).' })
+  score?: number
+
+  @Field({ nullable: true, description: 'Color code for this grade (for visualization purposes).' })
+  color?: string
+
+  @Field({ nullable: true, description: 'Indicates whether this KPI grade is active and usable.' })
   active?: boolean
-  
-  @Field({ nullable: true })
+
+  @Field({ nullable: true, description: 'Custom flag for update operations (internal use).' })
   cuFlag?: string
 }
 

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

@@ -1,95 +1,101 @@
 import {
   CreateDateColumn,
   UpdateDateColumn,
-  DeleteDateColumn,
   Entity,
   Index,
   Column,
   RelationId,
   ManyToOne,
-  VersionColumn,
   PrimaryGeneratedColumn
 } from 'typeorm'
-import { ObjectType, Field, Int, ID, registerEnumType } from 'type-graphql'
+import { ObjectType, Field, Int, ID, registerEnumType, Float } from 'type-graphql'
 
 import { Domain } from '@things-factory/shell'
 import { User } from '@things-factory/auth-base'
-
-export enum KpiGradeStatus {
-  STATUS_A = 'STATUS_A',
-  STATUS_B = 'STATUS_B'
-}
-
-registerEnumType(KpiGradeStatus, {
-  name: 'KpiGradeStatus',
-  description: 'state enumeration of a kpiGrade'
-})
+import { Kpi } from '../kpi/kpi'
 
 @Entity()
-@Index('ix_kpi_grade_0', (kpiGrade: KpiGrade) => [kpiGrade.domain, kpiGrade.name], {
-  where: '"deleted_at" IS NULL',
+@Index('ix_kpi_grade_0', (kpiGrade: KpiGrade) => [kpiGrade.domain, kpiGrade.kpi, kpiGrade.version, kpiGrade.name], {
   unique: true
 })
-@ObjectType({ description: 'Entity for KpiGrade' })
+@ObjectType({
+  description:
+    'KPI grade entity. Represents a grade/section for a KPI version, with value range, score, color, and description.'
+})
 export class KpiGrade {
   @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
+  @Field(type => ID, { description: 'Unique identifier for this KPI grade.' })
   readonly id: string
-  
-  @VersionColumn()
-  @Field({ nullable: true })
-  version?: number = 1
 
   @ManyToOne(type => Domain)
-  @Field({ nullable: true })
+  @Field({ nullable: true, description: 'Domain (tenant) to which this KPI grade belongs.' })
   domain?: Domain
 
   @RelationId((kpiGrade: KpiGrade) => kpiGrade.domain)
+  @Field({ nullable: true, description: 'ID of the domain (tenant) for this KPI grade.' })
   domainId?: string
 
   @Column()
-  @Field({ nullable: true })
+  @Field({ nullable: true, description: 'Name of the grade or section for this KPI.' })
   name?: string
 
   @Column({ nullable: true })
-  @Field({ nullable: true })
+  @Field({ nullable: true, description: 'Detailed description of this KPI grade.' })
   description?: string
 
   @Column({ nullable: false, default: false })
-  @Field({ nullable: true })
+  @Field({ nullable: true, description: 'Indicates whether this KPI grade is active and usable.' })
   active?: boolean
 
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  state?: KpiGradeStatus
+  @ManyToOne(() => Kpi)
+  @Field(type => Kpi, { description: 'Reference to the KPI to which this grade belongs.' })
+  kpi: Kpi
+
+  @RelationId((kpiGrade: KpiGrade) => kpiGrade.kpi)
+  @Field({ description: 'ID of the referenced KPI.' })
+  kpiId: string
+
+  @Column('int')
+  @Field(type => Int, { description: 'Version of the KPI definition to which this grade belongs.' })
+  version: number
+
+  @Column('float')
+  @Field(type => Float, { description: 'Minimum value for this grade section.' })
+  minValue: number
+
+  @Column('float')
+  @Field(type => Float, { description: 'Maximum value for this grade section.' })
+  maxValue: number
+
+  @Column({ nullable: true, type: 'float' })
+  @Field(type => Float, { nullable: true, description: 'Score or weight for this grade (optional).' })
+  score?: number
 
   @Column({ nullable: true })
-  @Field({ nullable: true })
-  params?: string
+  @Field({ nullable: true, description: 'Color code for this grade (for visualization purposes).' })
+  color?: string
 
   @CreateDateColumn()
-  @Field({ nullable: true })
+  @Field({ nullable: true, description: 'Timestamp when this KPI grade was created.' })
   createdAt?: Date
 
   @UpdateDateColumn()
-  @Field({ nullable: true })
+  @Field({ nullable: true, description: 'Timestamp when this KPI grade was last updated.' })
   updatedAt?: Date
 
-  @DeleteDateColumn()
-  @Field({ nullable: true })
-  deletedAt?: Date
-
   @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
+  @Field(type => User, { nullable: true, description: 'User who created this KPI grade.' })
   creator?: User
 
   @RelationId((kpiGrade: KpiGrade) => kpiGrade.creator)
+  @Field({ nullable: true, description: 'ID of the user who created this KPI grade.' })
   creatorId?: string
 
   @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
+  @Field(type => User, { nullable: true, description: 'User who last updated this KPI grade.' })
   updater?: User
 
   @RelationId((kpiGrade: KpiGrade) => kpiGrade.updater)
+  @Field({ nullable: true, description: 'ID of the user who last updated this KPI grade.' })
   updaterId?: string
 }