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

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

@@ -5,16 +5,28 @@ 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'
 
 @Resolver(Kpi)
 export class KpiMutation {
   @Directive('@transaction')
-  @Mutation(returns => Kpi, { description: 'To create new Kpi' })
-  async createKpi(@Arg('kpi') kpi: NewKpi, @Ctx() context: ResolverContext): Promise<Kpi> {
+  @Mutation(returns => Kpi, { description: 'Create a new KPI with the provided details.' })
+  async createKpi(
+    @Arg('kpi', { description: 'Input object containing details for the new KPI.' }) kpi: NewKpi,
+    @Ctx() context: ResolverContext
+  ): Promise<Kpi> {
     const { domain, user, tx } = context.state
 
+    let category = kpi.categoryId
+      ? await getRepository(KpiCategory).findOne({ where: { id: kpi.categoryId } })
+      : undefined
+
     const result = await getRepository(Kpi, tx).save({
       ...kpi,
+      category,
       domain,
       creator: user,
       updater: user
@@ -34,16 +46,57 @@ export class KpiMutation {
       )
     }
 
+    if (kpi.formula) {
+      const formulaService = new KpiFormulaService()
+      const result = await formulaService.validateFormula(kpi.formula)
+      if (!result.valid) {
+        throw new Error(result.errors.join('\n'))
+      }
+    }
+
+    // KPI 스케줄러 등록
+    if (kpi.schedule) {
+      const handle = await registerSchedule({
+        name: result.name,
+        client: {
+          application: Application,
+          group: `${domain.id}`,
+          type: 'kpi',
+          key: result.id,
+          operation: 'schedule'
+        },
+        type: 'cron',
+        schedule: kpi.schedule,
+        timezone: kpi.timezone,
+        task: {
+          type: 'rest',
+          connection: {
+            host: `${CallbackBase}/callback-schedule-for-kpi`,
+            headers: {
+              'Content-Type': 'application/json',
+              accept: '*/*'
+            }
+          },
+          data: {
+            domainId: domain.id,
+            kpiId: result.id
+          },
+          history_check: true,
+          failed_policy: 'retry_dlq',
+          max_retry_count: 3,
+          retry_period: 60
+        }
+      })
+      result.scheduleId = handle
+      await getRepository(Kpi, tx).save(result)
+    }
+
     return result
   }
 
   @Directive('@transaction')
   @Mutation(returns => Kpi, { description: 'To modify Kpi information' })
-  async updateKpi(
-    @Arg('id') id: string,
-    @Arg('patch') patch: KpiPatch,
-    @Ctx() context: ResolverContext
-  ): Promise<Kpi> {
+  async updateKpi(@Arg('id') id: string, @Arg('patch') patch: KpiPatch, @Ctx() context: ResolverContext): Promise<Kpi> {
     const { domain, user, tx } = context.state
 
     const repository = getRepository(Kpi, tx)
@@ -51,9 +104,14 @@ export class KpiMutation {
       where: { domain: { id: domain.id }, id }
     })
 
+    let category = patch.categoryId
+      ? await getRepository(KpiCategory).findOne({ where: { id: patch.categoryId } })
+      : kpi.category
+
     const result = await repository.save({
       ...kpi,
       ...patch,
+      category,
       updater: user
     })
 
@@ -72,11 +130,66 @@ export class KpiMutation {
       )
     }
 
+    if (patch.formula) {
+      const formulaService = new KpiFormulaService()
+      const result = await formulaService.validateFormula(patch.formula)
+      if (!result.valid) {
+        throw new Error(result.errors.join('\n'))
+      }
+    }
+
+    // KPI 스케줄러 등록/해제 갱신
+    if (patch.schedule) {
+      // 기존 스케줄러 해제
+      if (kpi.scheduleId) {
+        await unregisterSchedule(kpi.scheduleId)
+      }
+      // 새 스케줄러 등록
+      const handle = await registerSchedule({
+        name: result.name,
+        client: {
+          application: Application,
+          group: `${domain.id}`,
+          type: 'kpi',
+          key: result.id,
+          operation: 'schedule'
+        },
+        type: 'cron',
+        schedule: patch.schedule,
+        timezone: patch.timezone,
+        task: {
+          type: 'rest',
+          connection: {
+            host: `${CallbackBase}/callback-schedule-for-kpi`,
+            headers: {
+              'Content-Type': 'application/json',
+              accept: '*/*'
+            }
+          },
+          data: {
+            domainId: domain.id,
+            kpiId: result.id
+          },
+          history_check: true,
+          failed_policy: 'retry_dlq',
+          max_retry_count: 3,
+          retry_period: 60
+        }
+      })
+      result.scheduleId = handle
+      await repository.save(result)
+    } else if (patch.schedule === null && kpi.scheduleId) {
+      // 스케줄 해제 요청
+      await unregisterSchedule(kpi.scheduleId)
+      result.scheduleId = null
+      await repository.save(result)
+    }
+
     return result
   }
 
   @Directive('@transaction')
-  @Mutation(returns => [Kpi], { description: "To modify multiple Kpis' information" })
+  @Mutation(returns => Boolean, { description: "To modify multiple Kpis' information" })
   async updateMultipleKpi(
     @Arg('patches', type => [KpiPatch]) patches: KpiPatch[],
     @Ctx() context: ResolverContext
@@ -155,6 +268,11 @@ export class KpiMutation {
   async deleteKpi(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
     const { domain, tx } = context.state
 
+    const kpi = await getRepository(Kpi, tx).findOne({ where: { domain: { id: domain.id }, id } })
+    if (kpi && kpi.scheduleId) {
+      await unregisterSchedule(kpi.scheduleId)
+    }
+
     await getRepository(Kpi, tx).delete({ domain: { id: domain.id }, id })
     await deleteAttachmentsByRef(null, { refBys: [id] }, context)
 
@@ -163,10 +281,7 @@ export class KpiMutation {
 
   @Directive('@transaction')
   @Mutation(returns => Boolean, { description: 'To delete multiple Kpis' })
-  async deleteKpis(
-    @Arg('ids', type => [String]) ids: string[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
+  async deleteKpis(@Arg('ids', type => [String]) ids: string[], @Ctx() context: ResolverContext): Promise<boolean> {
     const { domain, tx } = context.state
 
     await getRepository(Kpi, tx).delete({
@@ -195,4 +310,71 @@ export class KpiMutation {
 
     return true
   }
+
+  @Directive('@transaction')
+  @Mutation(returns => Kpi, { description: 'Release a KPI and create a version history.' })
+  async releaseKpi(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Kpi> {
+    const { domain, user, tx } = context.state
+    const repository = getRepository(Kpi, tx)
+    const historyRepository = getRepository(KpiHistory, tx)
+
+    const kpi = await repository.findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+    if (!kpi) throw `KPI given id(${id}) is not found`
+    if (kpi.state == 'RELEASE') throw `KPI given id(${id}) is already released`
+
+    // 히스토리에서 max version 가져오기
+    const maxHistory = await historyRepository
+      .createQueryBuilder('history')
+      .select('MAX(history.version)', 'max')
+      .where('history.originalId = :id', { id: kpi.id })
+      .getRawOne()
+    const nextVersion = maxHistory?.max ? Number(maxHistory.max) + 1 : 1
+
+    const updated = await repository.save({
+      ...kpi,
+      version: nextVersion,
+      state: 'RELEASE',
+      updater: user
+    } as any)
+    return updated
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Kpi, { description: 'Revert a KPI to a specific historical version.' })
+  async revertKpiVersion(
+    @Arg('id') id: string,
+    @Arg('version') version: number,
+    @Ctx() context: ResolverContext
+  ): Promise<Kpi> {
+    const { domain, user, tx } = context.state
+    const repository = getRepository(Kpi, tx)
+    const historyRepository = getRepository(KpiHistory, tx)
+
+    const kpi = await repository.findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+    if (!kpi) throw `KPI with id(${id}) is not found`
+
+    const kpiHistory = await historyRepository.findOne({
+      where: { domain: { id: domain.id }, originalId: id, version },
+      order: { version: 'DESC' }
+    })
+    if (!kpiHistory) throw `KPI with id:version(${id}:${version}) is not found`
+
+    const updated = await repository.save({
+      ...kpi,
+      name: kpiHistory.name,
+      description: kpiHistory.description,
+      category: kpiHistory.category,
+      categoryId: kpiHistory.categoryId,
+      formula: kpiHistory.formula,
+      active: kpiHistory.active,
+      state: 'DRAFT',
+      thumbnail: kpiHistory.thumbnail,
+      updater: user
+    } as any)
+    return updated
+  }
 }

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

@@ -4,11 +4,19 @@ import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from
 import { User } from '@things-factory/auth-base'
 import { Kpi } from './kpi'
 import { KpiList } from './kpi-type'
+import { KpiGrade } from '../kpi-grade/kpi-grade'
+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 {
-  @Query(returns => Kpi!, { nullable: true, description: 'To fetch a Kpi' })
-  async kpi(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Kpi> {
+  @Query(returns => Kpi!, { nullable: true, description: 'Fetch a single KPI by its unique identifier.' })
+  async kpi(
+    @Arg('id', { description: 'Unique identifier of the KPI to fetch.' }) id: string,
+    @Ctx() context: ResolverContext
+  ): Promise<Kpi> {
     const { domain } = context.state
 
     return await getRepository(Kpi).findOne({
@@ -45,6 +53,11 @@ export class KpiQuery {
     return attachment?.fullpath
   }
 
+  @FieldResolver(type => [KpiGrade])
+  async grades(@Root() kpi: Kpi): Promise<KpiGrade[]> {
+    return await getRepository(KpiGrade).find({ where: { domain: { id: kpi.domainId }, kpi: { id: kpi.id } } })
+  }
+
   @FieldResolver(type => Domain)
   async domain(@Root() kpi: Kpi): Promise<Domain> {
     return kpi.domainId && (await getRepository(Domain).findOneBy({ id: kpi.domainId }))
@@ -59,4 +72,46 @@ export class KpiQuery {
   async creator(@Root() kpi: Kpi): Promise<User> {
     return kpi.creatorId && (await getRepository(User).findOneBy({ id: kpi.creatorId }))
   }
+
+  @FieldResolver(type => KpiValue, { nullable: true })
+  async value(@Root() kpi: Kpi, @Ctx() context): Promise<KpiValue | null> {
+    const { domain } = context.state
+    return await getRepository(KpiValue).findOne({
+      where: { domain: { id: domain.id }, kpi: { id: kpi.id } },
+      order: { valueDate: 'DESC' }
+    })
+  }
+
+  @FieldResolver(type => Number, { nullable: true })
+  targetValue(@Root() kpi: Kpi): number | undefined {
+    return kpi.vizMeta?.targetValue
+  }
+
+  @FieldResolver(type => String, { nullable: true })
+  unit(@Root() kpi: Kpi): string | undefined {
+    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 => [KpiHistory], { nullable: true })
+  async histories(
+    @Root() kpi: Kpi,
+    @Ctx() context,
+    @Arg('limit', type => Int, { nullable: true }) limit?: number
+  ): Promise<KpiHistory[]> {
+    const { domain } = context.state
+    const qb = getRepository(KpiHistory)
+      .createQueryBuilder('history')
+      .where('history.domain = :domainId', { domainId: domain.id })
+      .andWhere('history.kpi = :kpiId', { kpiId: kpi.id })
+      .orderBy('history.updatedAt', 'DESC')
+    if (limit) qb.limit(limit)
+    else qb.limit(1)
+    return await qb.getMany()
+  }
 }

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

@@ -6,49 +6,102 @@ import { ObjectRef, ScalarObject } from '@things-factory/shell'
 
 import { Kpi, KpiStatus } from './kpi'
 
-@InputType()
+@InputType({ description: 'Input type for creating a new KPI. Used in mutations to provide KPI details.' })
 export class NewKpi {
-  @Field()
+  @Field({ description: 'Name of the KPI.' })
   name: string
 
-  @Field({ nullable: true })
+  @Field({ nullable: true, description: 'Detailed description of the KPI.' })
   description?: string
 
-  @Field(type => KpiStatus, { nullable: true })
-  state?: KpiStatus
+  @Field(type => ID, { nullable: true, description: 'ID of the category to which this KPI belongs.' })
+  categoryId?: string
+
+  @Field({ nullable: true, description: 'Calculation formula for the KPI, using metric codes and operators.' })
+  formula?: string
 
-  @Field({ nullable: true })
+  @Field({ nullable: true, description: 'Indicates whether this KPI is active and usable.' })
   active?: boolean
 
-  @Field({ nullable: true })
-  params?: string
+  @Field(type => KpiStatus, { nullable: true, description: 'Current state of the KPI (DRAFT, RELEASED, ARCHIVED).' })
+  state?: KpiStatus
 
-  @Field(type => GraphQLUpload, { nullable: true })
+  @Field(type => GraphQLUpload, { nullable: true, description: 'Thumbnail image or file for this KPI.' })
   thumbnail?: FileUpload
+
+  @Field({
+    nullable: true,
+    description: 'Visualization type for this KPI (e.g., bar, line, gauge, progress, card, table, icon, badge, text).'
+  })
+  vizType?: string
+
+  @Field(type => ScalarObject, {
+    nullable: true,
+    description:
+      'Visualization options and metadata for this KPI, such as color, icon, thresholds, unit, decimal places, etc.'
+  })
+  vizMeta?: any
+
+  @Field({
+    nullable: true,
+    description: 'Cron schedule string for periodic KPI value aggregation (e.g., "0 0 * * *" for daily).'
+  })
+  schedule?: string
+
+  @Field({ nullable: true, description: 'Timezone for the KPI schedule.' })
+  timezone?: string
 }
 
-@InputType()
+@InputType({ description: 'Input type for updating an existing KPI. Used in mutations to patch KPI details.' })
 export class KpiPatch {
-  @Field(type => ID, { nullable: true })
+  @Field(type => ID, { nullable: true, description: 'ID of the KPI to update.' })
   id?: string
 
-  @Field({ nullable: true })
+  @Field({ nullable: true, description: 'Name of the KPI.' })
   name?: string
 
-  @Field({ nullable: true })
+  @Field({ nullable: true, description: 'Detailed description of the KPI.' })
   description?: string
 
-  @Field(type => KpiStatus, { nullable: true })
-  state?: KpiStatus
+  @Field(type => ID, { nullable: true, description: 'ID of the category to which this KPI belongs.' })
+  categoryId?: string
+
+  @Field({ nullable: true, description: 'Calculation formula for the KPI, using metric codes and operators.' })
+  formula?: string
 
-  @Field({ nullable: true })
+  @Field({ nullable: true, description: 'Indicates whether this KPI is active and usable.' })
   active?: boolean
 
-  @Field(type => GraphQLUpload, { nullable: true })
+  @Field(type => KpiStatus, { nullable: true, description: 'Current state of the KPI (DRAFT, RELEASED, ARCHIVED).' })
+  state?: KpiStatus
+
+  @Field(type => GraphQLUpload, { nullable: true, description: 'Thumbnail image or file for this KPI.' })
   thumbnail?: FileUpload
-  
-  @Field({ nullable: true })
+
+  @Field({
+    nullable: true,
+    description: 'Visualization type for this KPI (e.g., bar, line, gauge, progress, card, table, icon, badge, text).'
+  })
+  vizType?: string
+
+  @Field(type => ScalarObject, {
+    nullable: true,
+    description:
+      'Visualization options and metadata for this KPI, such as color, icon, thresholds, unit, decimal places, etc.'
+  })
+  vizMeta?: any
+
+  @Field({ nullable: true, description: 'Custom flag for update operations (internal use).' })
   cuFlag?: string
+
+  @Field({
+    nullable: true,
+    description: 'Cron schedule string for periodic KPI value aggregation (e.g., "0 0 * * *" for daily).'
+  })
+  schedule?: string
+
+  @Field({ nullable: true, description: 'Timezone for the KPI schedule.' })
+  timezone?: string
 }
 
 @ObjectType()

package/server/service/kpi/kpi.ts

@@ -7,6 +7,7 @@ import {
   Column,
   RelationId,
   ManyToOne,
+  OneToMany,
   VersionColumn,
   PrimaryGeneratedColumn
 } from 'typeorm'
@@ -14,15 +15,23 @@ 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 { KpiGrade } from '../kpi-grade/kpi-grade'
+import { config } from '@things-factory/env'
+import { ScalarObject } from '@things-factory/shell'
+
+const ORMCONFIG = config.get('ormconfig', {})
+const DATABASE_TYPE = ORMCONFIG.type
 
 export enum KpiStatus {
-  STATUS_A = 'STATUS_A',
-  STATUS_B = 'STATUS_B'
+  DRAFT = 'DRAFT',
+  RELEASE = 'RELEASE',
+  ARCHIVED = 'ARCHIVED'
 }
 
 registerEnumType(KpiStatus, {
   name: 'KpiStatus',
-  description: 'state enumeration of a kpi'
+  description: 'State enumeration of a KPI (DRAFT, RELEASED, ARCHIVED)'
 })
 
 @Entity()
@@ -30,69 +39,136 @@ registerEnumType(KpiStatus, {
   where: '"deleted_at" IS NULL',
   unique: true
 })
-@ObjectType({ description: 'Entity for Kpi' })
+@ObjectType({
+  description:
+    'KPI entity. Represents a key performance indicator with calculation formula, target, category, and other attributes.'
+})
 export class Kpi {
   @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
+  @Field(type => ID, { description: 'Unique identifier for this KPI.' })
   readonly id: string
-  
+
   @VersionColumn()
-  @Field({ nullable: true })
+  @Field({
+    nullable: true,
+    description:
+      'Version number of the KPI. Increments on each modification. When the KPI is released, a snapshot is saved in kpi-history and the status becomes RELEASED. Editing after release increases the version and sets status to DRAFT.'
+  })
   version?: number = 1
 
   @ManyToOne(type => Domain)
-  @Field({ nullable: true })
+  @Field({ nullable: true, description: 'Domain (tenant) to which this KPI belongs.' })
   domain?: Domain
 
   @RelationId((kpi: Kpi) => kpi.domain)
+  @Field({ nullable: true, description: 'ID of the domain (tenant) for this KPI.' })
   domainId?: string
 
   @Column()
-  @Field({ nullable: true })
+  @Field({ nullable: true, description: 'Name of the KPI.' })
   name?: string
 
   @Column({ nullable: true })
-  @Field({ nullable: true })
+  @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
+
+  @RelationId((kpi: Kpi) => kpi.category)
+  @Field({ nullable: true, description: 'ID of the category for this KPI.' })
+  categoryId?: string
+
+  @Column({
+    nullable: true,
+    type:
+      DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb'
+        ? 'longtext'
+        : DATABASE_TYPE == 'oracle'
+          ? 'clob'
+          : DATABASE_TYPE == 'mssql'
+            ? 'nvarchar'
+            : 'varchar',
+    length: DATABASE_TYPE == 'mssql' ? 'MAX' : undefined
+  })
+  @Field({
+    nullable: true,
+    description:
+      'Calculation formula for the KPI. Expressed as a string using metric codes and operators, e.g., "defect_count / total_count * 100".'
+  })
+  formula?: string
+
   @Column({ nullable: false, default: false })
-  @Field({ nullable: true })
+  @Field({ nullable: true, description: 'Indicates whether this KPI is active and usable.' })
   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({
+    nullable: true,
+    description: 'Visualization type for this KPI (e.g., bar, line, gauge, progress, card, table, icon, badge, text).'
+  })
+  vizType?: string
+
+  @Column({ type: 'json', nullable: true })
+  @Field(type => ScalarObject, {
+    nullable: true,
+    description:
+      'Visualization options and metadata for this KPI, such as color, icon, thresholds, unit, decimal places, etc.'
+  })
+  vizMeta?: any
+
+  @Column({ nullable: true })
+  @Field({
+    nullable: true,
+    description: 'Cron schedule string for periodic KPI value aggregation (e.g., "0 0 * * *" for daily).'
+  })
+  schedule?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true, description: 'Schedule ID for the KPI (used for scheduler registration).' })
+  scheduleId?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true, description: 'Timezone for the KPI schedule.' })
+  timezone?: string
 
   @CreateDateColumn()
-  @Field({ nullable: true })
+  @Field({ nullable: true, description: 'Timestamp when this KPI was created.' })
   createdAt?: Date
 
   @UpdateDateColumn()
-  @Field({ nullable: true })
+  @Field({ nullable: true, description: 'Timestamp when this KPI was last updated.' })
   updatedAt?: Date
 
   @DeleteDateColumn()
-  @Field({ nullable: true })
+  @Field({ nullable: true, description: 'Timestamp when this KPI was deleted (soft delete).' })
   deletedAt?: Date
 
   @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
+  @Field(type => User, { nullable: true, description: 'User who created this KPI.' })
   creator?: User
 
   @RelationId((kpi: Kpi) => kpi.creator)
+  @Field({ nullable: true, description: 'ID of the user who created this KPI.' })
   creatorId?: string
 
   @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
+  @Field(type => User, { nullable: true, description: 'User who last updated this KPI.' })
   updater?: User
 
   @RelationId((kpi: Kpi) => kpi.updater)
+  @Field({ nullable: true, description: 'ID of the user who last updated this KPI.' })
   updaterId?: string
 
-  @Field(type => String, { nullable: true })
+  @Field(type => String, { nullable: true, description: 'Thumbnail image or file path for this KPI.' })
   thumbnail?: string
+
+  @OneToMany(type => KpiGrade, kpiGrade => kpiGrade.kpi)
+  @Field(type => [KpiGrade], { nullable: true, description: 'List of grades for this KPI.' })
+  grades?: KpiGrade[]
 }

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

@@ -0,0 +1,3 @@
+import { KpiAlertQuery } from './kpi-alert-query'
+
+export const resolvers = [KpiAlertQuery]