@things-factory/kpi 9.1.19 → 10.0.0-beta.2

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

@@ -1,134 +0,0 @@
-import {
-  CreateDateColumn,
-  UpdateDateColumn,
-  DeleteDateColumn,
-  Entity,
-  Index,
-  Column,
-  RelationId,
-  ManyToOne,
-  PrimaryGeneratedColumn
-} from 'typeorm'
-import { ObjectType, Field, Int, ID, registerEnumType } from 'type-graphql'
-
-import { Domain } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-import { DataSet } from '@things-factory/dataset'
-import { KpiPeriodType } from '../kpi/kpi'
-
-export enum KpiMetricCollectType {
-  AUTO = 'AUTO', // 데이터셋 등 자동 수집
-  MANUAL = 'MANUAL', // 수동 입력
-  IMPORT = 'IMPORT', // 외부 파일 등 임포트
-  EXTERNAL = 'EXTERNAL' // 외부 API 등
-}
-registerEnumType(KpiMetricCollectType, {
-  name: 'KpiMetricCollectType',
-  description: '방식: AUTO(자동), MANUAL(수동), IMPORT(임포트), EXTERNAL(외부API)'
-})
-
-@Entity()
-@Index('ix_kpi_metric_0', (kpiMetric: KpiMetric) => [kpiMetric.domain, kpiMetric.name], {
-  where: '"deleted_at" IS NULL',
-  unique: true
-})
-@ObjectType({ description: 'KPI metric entity. Represents a source data item used in KPI formulas.' })
-export class KpiMetric {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID, { description: 'Unique identifier for this KPI metric.' })
-  readonly id: string
-
-  @ManyToOne(type => Domain)
-  @Field({ nullable: true, description: 'Domain (tenant) to which this KPI metric belongs.' })
-  domain?: Domain
-
-  @RelationId((metric: KpiMetric) => metric.domain)
-  @Field({ nullable: true, description: 'ID of the domain (tenant) for this KPI metric.' })
-  domainId?: string
-
-  @Column()
-  @Field({ description: 'Metric code, unique within the domain, used in KPI formulas.' })
-  name: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'User-friendly name or description of the metric.' })
-  description?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Unit of measurement for this metric (e.g., %, count, hours).' })
-  unit?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Source of the metric data (e.g., system, method, dataset).' })
-  source?: string
-
-  @ManyToOne(type => DataSet, { nullable: true })
-  @Field(type => DataSet, { nullable: true, description: 'Reference to the source dataset for this metric.' })
-  dataSet?: DataSet
-
-  @RelationId((metric: KpiMetric) => metric.dataSet)
-  @Field({ nullable: true, description: 'ID of the referenced source dataset.' })
-  dataSetId?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Name of the field in the dataset this metric maps to.' })
-  fieldName?: string
-
-  @Column({ nullable: false, default: false })
-  @Field({ nullable: true, description: 'Indicates whether this metric is active and usable.' })
-  active?: boolean
-
-  @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 registered cron job.' })
-  scheduleId?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Timezone for the schedule.' })
-  timezone?: string
-
-  @Column({ type: 'enum', enum: KpiMetricCollectType, default: KpiMetricCollectType.AUTO })
-  @Field(type => KpiMetricCollectType, { description: '데이터 수집 방식' })
-  collectType: KpiMetricCollectType
-
-  @Column({ default: 'DAY' })
-  @Field(type => KpiPeriodType, { description: 'Aggregation period type for this metric.' })
-  periodType: KpiPeriodType
-
-  @CreateDateColumn()
-  @Field({ nullable: true, description: 'Timestamp when this KPI metric was created.' })
-  createdAt?: Date
-
-  @UpdateDateColumn()
-  @Field({ nullable: true, description: 'Timestamp when this KPI metric was last updated.' })
-  updatedAt?: Date
-
-  @DeleteDateColumn()
-  @Field({ nullable: true, description: 'Timestamp when this KPI metric was deleted (soft delete).' })
-  deletedAt?: Date
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true, description: 'User who created this KPI metric.' })
-  creator?: User
-
-  @RelationId((metric: KpiMetric) => metric.creator)
-  @Field({ nullable: true, description: 'ID of the user who created this KPI metric.' })
-  creatorId?: string
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true, description: 'User who last updated this KPI metric.' })
-  updater?: User
-
-  @RelationId((metric: KpiMetric) => metric.updater)
-  @Field({ nullable: true, description: 'ID of the user who last updated this KPI metric.' })
-  updaterId?: string
-
-  @Field(type => String, { nullable: true, description: 'Thumbnail image or file path for this KPI metric.' })
-  thumbnail?: string
-}

package/server/service/kpi-metric-value/index.ts

@@ -1,7 +0,0 @@
-import { KpiMetricValue } from './kpi-metric-value'
-import { KpiMetricValueQuery } from './kpi-metric-value-query'
-import { KpiMetricValueMutation } from './kpi-metric-value-mutation'
-
-export const entities = [KpiMetricValue]
-export const resolvers = [KpiMetricValueQuery, KpiMetricValueMutation]
-export const subscribers = []

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

@@ -1,270 +0,0 @@
-import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
-import { In } from 'typeorm'
-import { getRepository } from '@things-factory/shell'
-import { Float } from 'type-graphql'
-import { KpiPeriodType } from '../kpi/kpi'
-
-import { KpiMetricValue } from './kpi-metric-value'
-import { NewKpiMetricValue, KpiMetricValuePatch } from './kpi-metric-value-type'
-import { KpiMetric } from '../kpi-metric/kpi-metric'
-import { ScalarObject } from '@things-factory/shell'
-import { getDefaultValueDate } from '../utils/value-date-util'
-
-@Resolver(KpiMetricValue)
-export class KpiMetricValueMutation {
-  @Directive('@transaction')
-  @Directive('@privilege(category: "kpi", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
-  @Mutation(returns => KpiMetricValue, { description: 'Create a new metric value with the provided details.' })
-  async createKpiMetricValue(
-    @Arg('metricValue', { description: 'Input object containing details for the new metric value.' })
-    metricValue: NewKpiMetricValue,
-    @Ctx() context: ResolverContext
-  ): Promise<KpiMetricValue> {
-    const { domain, user, tx } = context.state
-
-    let metric = metricValue.metricId
-      ? await getRepository(KpiMetric).findOne({ where: { id: metricValue.metricId } })
-      : undefined
-
-    // valueDate 자동 생성/보정 로직 추가
-    let periodType = metricValue.periodType
-    if (!periodType && metric) {
-      periodType = metric.periodType
-    }
-    if (!periodType) {
-      periodType = KpiPeriodType.DAY
-    }
-    // periodType을 string으로 변환 후 KpiPeriodType으로 강제 변환
-    periodType = KpiPeriodType[String(periodType) as keyof typeof KpiPeriodType]
-    let valueDate = metricValue.valueDate
-    if (!valueDate || !isValueDateValidForPeriodType(valueDate, periodType)) {
-      valueDate = getDefaultValueDate(periodType)
-    }
-
-    const entity: Partial<KpiMetricValue> = {
-      metric,
-      metricId: metricValue.metricId,
-      valueDate,
-      periodType,
-      value: metricValue.value,
-      org: metricValue.org,
-      unit: metricValue.unit,
-      meta: metricValue.meta,
-      domain: domain,
-      creator: user,
-      updater: user
-    }
-
-    return await getRepository(KpiMetricValue, tx).save(entity)
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "kpi", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
-  @Mutation(returns => KpiMetricValue, { description: 'Record a metric value by metric name, value, meta, and org.' })
-  async recordKpiMetricValue(
-    @Arg('metricName', { description: 'Metric code/name.' }) metricName: string,
-    @Arg('value', type => Float, { nullable: true, description: 'Metric value (number).' }) value: number | null,
-    @Arg('meta', type => ScalarObject, { nullable: true, description: 'Extended or non-numeric information (JSON).' })
-    meta: any,
-    @Arg('org', { nullable: true, description: 'Organizational unit for this value (project, department, company, employee, etc.)' })
-    org: string | null,
-    @Ctx() context: ResolverContext
-  ): Promise<KpiMetricValue> {
-    const { domain, user, tx } = context.state
-    const metric = await getRepository(KpiMetric).findOne({ where: { name: metricName, domain: { id: domain.id } } })
-    if (!metric) throw new Error(`Metric not found: ${metricName}`)
-    const periodType = metric.periodType || KpiPeriodType.DAY
-    const valueDate = getDefaultValueDate(periodType)
-    if (value == null && meta == null) {
-      throw new Error('Either value or meta must be provided.')
-    }
-    const repo = getRepository(KpiMetricValue, tx)
-    let entity = await repo.findOne({
-      where: {
-        metric: { id: metric.id },
-        valueDate,
-        periodType,
-        org,
-        domain: { id: domain.id }
-      }
-    })
-    if (entity) {
-      entity.value = value
-      entity.meta = meta
-      entity.updater = user
-    } else {
-      entity = repo.create({
-        metric,
-        metricId: metric.id,
-        value,
-        meta,
-        valueDate,
-        periodType,
-        org,
-        domain,
-        creator: user,
-        updater: user
-      })
-    }
-    return await repo.save(entity)
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "kpi", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
-  @Mutation(returns => KpiMetricValue, { description: 'To modify KpiMetricValue information' })
-  async updateKpiMetricValue(
-    @Arg('id') id: string,
-    @Arg('patch') patch: KpiMetricValuePatch,
-    @Ctx() context: ResolverContext
-  ): Promise<KpiMetricValue> {
-    const { domain, user, tx } = context.state
-
-    const repository = getRepository(KpiMetricValue, tx)
-    const metricValue = await repository.findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-
-    let metric = patch.metricId
-      ? await getRepository(KpiMetric).findOne({ where: { id: patch.metricId } })
-      : metricValue.metric
-
-    const entity: any = {
-      ...metricValue,
-      ...patch,
-      metric,
-      updater: user
-    }
-
-    return await repository.save(entity)
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "kpi", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
-  @Mutation(returns => [KpiMetricValue], { description: "To modify multiple KpiMetricValues' information" })
-  async updateMultipleKpiMetricValue(
-    @Arg('patches', type => [KpiMetricValuePatch]) patches: KpiMetricValuePatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<KpiMetricValue[]> {
-    const { domain, user, tx } = context.state
-
-    let results = []
-    const _createRecords = patches.filter((patch: any) => patch.cuFlag && patch.cuFlag.toUpperCase() === '+')
-    const _updateRecords = patches.filter((patch: any) => patch.cuFlag && patch.cuFlag.toUpperCase() === 'M')
-    const metricValueRepo = getRepository(KpiMetricValue, tx)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        if (!newRecord.metricId) {
-          throw new Error('metricId is required for creating new metric value')
-        }
-
-        const metric = await getRepository(KpiMetric).findOne({
-          where: { domain: { id: domain.id }, id: newRecord.metricId }
-        })
-
-        if (!metric) {
-          throw new Error(`Metric not found: ${newRecord.metricId}`)
-        }
-
-        const result = await metricValueRepo.save({
-          ...newRecord,
-          metric,
-          domain,
-          creator: user,
-          updater: user
-        } as any)
-        results.push({ ...result, cuFlag: '+' })
-      }
-    }
-
-    if (_updateRecords.length > 0) {
-      for (let i = 0; i < _updateRecords.length; i++) {
-        const updateRecord = _updateRecords[i]
-        const metricValue = await metricValueRepo.findOneBy({ id: updateRecord.id })
-
-        if (!updateRecord.metricId) {
-          throw new Error('metricId is required for updating value')
-        }
-
-        const metric = await getRepository(KpiMetric).findOne({
-          where: { domain: { id: domain.id }, id: updateRecord.metricId }
-        })
-
-        if (!metric) {
-          throw new Error(`Metric not found: ${updateRecord.metricId}`)
-        }
-
-        const result = await metricValueRepo.save({
-          ...metricValue,
-          ...updateRecord,
-          metric,
-          updater: user
-        } as any)
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "kpi", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
-  @Mutation(returns => Boolean, { description: 'To delete KpiMetricValue' })
-  async deleteKpiMetricValue(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-    await getRepository(KpiMetricValue, tx).delete({ domain: { id: domain.id }, id })
-    return true
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "kpi", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
-  @Mutation(returns => Boolean, { description: 'To delete multiple KpiMetricValues' })
-  async deleteKpiMetricValues(
-    @Arg('ids', type => [String]) ids: string[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-    await getRepository(KpiMetricValue, tx).delete({
-      domain: { id: domain.id },
-      id: In(ids)
-    })
-    return true
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "kpi", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
-  @Mutation(returns => Boolean, { description: 'To import multiple KpiMetricValues' })
-  async importKpiMetricValues(
-    @Arg('metricValues', type => [KpiMetricValuePatch]) metricValues: KpiMetricValuePatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-    await Promise.all(
-      metricValues.map(async (metricValue: KpiMetricValuePatch) => {
-        await getRepository(KpiMetricValue, tx).save({ domain, ...metricValue } as any)
-      })
-    )
-    return true
-  }
-}
-
-// valueDate와 periodType의 일치 여부를 검사하는 유틸리티 함수(임시, 아래에 추가)
-function isValueDateValidForPeriodType(valueDate: string, periodType: KpiPeriodType): boolean {
-  if (!valueDate) return false
-  switch (periodType) {
-    case KpiPeriodType.DAY:
-      return /^\d{4}-\d{2}-\d{2}$/.test(valueDate)
-    case KpiPeriodType.MONTH:
-      return /^\d{4}-\d{2}$/.test(valueDate)
-    case KpiPeriodType.QUARTER:
-      return /^\d{4}-Q[1-4]$/.test(valueDate)
-    case KpiPeriodType.WEEK:
-      return /^\d{4}-W\d{1,2}$/.test(valueDate)
-    case KpiPeriodType.ALLTIME:
-      return valueDate === 'ALLTIME'
-    default:
-      return true
-  }
-}

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

@@ -1,62 +0,0 @@
-import { Directive, Resolver, Query, Args, Arg, Ctx, FieldResolver, Root } from 'type-graphql'
-import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-import { KpiMetricValue } from './kpi-metric-value'
-import { KpiMetricValueList } from './kpi-metric-value-type'
-import { KpiMetric } from '../kpi-metric/kpi-metric'
-
-@Resolver(KpiMetricValue)
-export class KpiMetricValueQuery {
-  @Directive('@privilege(category: "kpi", privilege: "query", domainOwnerGranted: true, superUserGranted: true)')
-  @Query(returns => KpiMetricValueList, { description: 'To fetch multiple KpiMetricValues' })
-  async kpiMetricValues(
-    @Args(type => ListParam) params: ListParam,
-    @Ctx() context: ResolverContext
-  ): Promise<KpiMetricValueList> {
-    const { domain } = context.state
-    const queryBuilder = getQueryBuilderFromListParams({
-      domain,
-      params,
-      repository: await getRepository(KpiMetricValue),
-      searchables: ['metricId', 'group', 'valueDate']
-    })
-    const [items, total] = await queryBuilder.getManyAndCount()
-    return { items, total }
-  }
-
-  @Directive('@privilege(category: "kpi", privilege: "query", domainOwnerGranted: true, superUserGranted: true)')
-  @Query(returns => KpiMetricValue, {
-    nullable: true,
-    description: 'Fetch a single metric value by its unique identifier.'
-  })
-  async kpiMetricValue(
-    @Arg('id', { description: 'Unique identifier of the metric value to fetch.' }) id: string,
-    @Ctx() context: ResolverContext
-  ): Promise<KpiMetricValue | null> {
-    const { domain } = context.state
-    return await getRepository(KpiMetricValue).findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() metricValue: KpiMetricValue): Promise<Domain> {
-    return metricValue.domainId && (await getRepository(Domain).findOneBy({ id: metricValue.domainId }))
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() metricValue: KpiMetricValue): Promise<User> {
-    return metricValue.updaterId && (await getRepository(User).findOneBy({ id: metricValue.updaterId }))
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() metricValue: KpiMetricValue): Promise<User> {
-    return metricValue.creatorId && (await getRepository(User).findOneBy({ id: metricValue.creatorId }))
-  }
-
-  @FieldResolver(type => KpiMetric)
-  async metric(@Root() metricValue: KpiMetricValue): Promise<KpiMetric | null> {
-    if (!metricValue.metricId) return null
-    return await getRepository(KpiMetric).findOneBy({ id: metricValue.metricId })
-  }
-}

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

@@ -1,82 +0,0 @@
-import { ObjectType, Field, ID, Float, InputType, Int } from 'type-graphql'
-import { ScalarObject } from '@things-factory/shell'
-import { KpiMetricValue } from './kpi-metric-value'
-import { KpiPeriodType } from '../kpi/kpi'
-
-@InputType({
-  description: 'Input type for creating a new metric value. Used in mutations to provide metric value details.'
-})
-export class NewKpiMetricValue {
-  @Field(type => ID, { description: 'ID of the metric to which this value belongs.' })
-  metricId: string
-
-  @Field({ description: 'Date or period for which this metric value is recorded (e.g., day, month, quarter, range).' })
-  valueDate: string
-
-  @Field(type => KpiPeriodType, { description: 'Aggregation period type for this metric value.' })
-  periodType: KpiPeriodType
-
-  @Field(type => Float, { description: 'The value for this metric and period.' })
-  value: number
-
-  @Field({ nullable: true, description: 'Unit of measurement for this metric value.' })
-  unit?: string
-
-  @Field(type => ScalarObject, {
-    nullable: true,
-    description:
-      'Extended or non-numeric information related to this metric value, stored as JSON. Can include status, comments, or other metadata.'
-  })
-  meta?: any
-
-  @Field({ nullable: true, description: 'Organizational unit for this value (project, department, company, employee, etc.)' })
-  org?: string
-}
-
-@InputType({
-  description: 'Input type for updating an existing metric value. Used in mutations to patch metric value details.'
-})
-export class KpiMetricValuePatch {
-  @Field(type => ID, { nullable: true, description: 'ID of the metric value to update.' })
-  id?: string
-
-  @Field(type => ID, { nullable: true, description: 'ID of the metric to which this value belongs.' })
-  metricId?: string
-
-  @Field({
-    nullable: true,
-    description: 'Date or period for which this metric value is recorded (e.g., day, month, quarter, range).'
-  })
-  valueDate?: string
-
-  @Field(type => KpiPeriodType, { nullable: true, description: 'Aggregation period type for this metric value.' })
-  periodType?: KpiPeriodType
-
-  @Field(type => Float, { nullable: true, description: 'The value for this metric and period.' })
-  value?: number
-
-  @Field({ nullable: true, description: 'Unit of measurement for this metric value.' })
-  unit?: string
-
-  @Field(type => ScalarObject, {
-    nullable: true,
-    description:
-      'Extended or non-numeric information related to this metric value, stored as JSON. Can include status, comments, or other metadata.'
-  })
-  meta?: any
-
-  @Field({ nullable: true, description: 'Organizational unit for this value (project, department, company, employee, etc.)' })
-  org?: string
-
-  @Field({ nullable: true, description: 'Custom flag for update operations (internal use).' })
-  cuFlag?: string
-}
-
-@ObjectType()
-export class KpiMetricValueList {
-  @Field(type => [KpiMetricValue])
-  items: KpiMetricValue[]
-
-  @Field(type => Int)
-  total: number
-}

package/server/service/kpi-metric-value/kpi-metric-value.ts

@@ -1,93 +0,0 @@
-import {
-  Entity,
-  PrimaryGeneratedColumn,
-  Column,
-  ManyToOne,
-  Index,
-  JoinColumn,
-  CreateDateColumn,
-  UpdateDateColumn,
-  RelationId
-} from 'typeorm'
-import { ObjectType, Field, ID, Float } from 'type-graphql'
-import { Domain, ScalarObject } from '@things-factory/shell'
-import { KpiMetric } from '../kpi-metric/kpi-metric'
-import { KpiPeriodType } from '../kpi/kpi'
-import { User } from '@things-factory/auth-base'
-
-@Entity()
-@Index('ix_kpi_metric_value_latest', ['domain', 'metric', 'valueDate', 'org'], { unique: true })
-@ObjectType({ description: 'Current value for each KPI metric (can be used for both state and history).' })
-export class KpiMetricValue {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  id: string
-
-  @ManyToOne(() => Domain)
-  @Field(type => Domain, { nullable: true })
-  domain?: Domain
-
-  @RelationId((entity: KpiMetricValue) => entity.domain)
-  @Field({ nullable: true })
-  domainId?: string
-
-  @ManyToOne(() => KpiMetric, { nullable: false, onDelete: 'CASCADE' })
-  @JoinColumn({ name: 'metricId' })
-  @Field(type => KpiMetric)
-  metric: KpiMetric
-
-  @RelationId((entity: KpiMetricValue) => entity.metric)
-  @Field()
-  metricId: string
-
-  @Column('float')
-  @Field(type => Float)
-  value: number
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  unit?: string
-
-  @Column()
-  @Field({
-    description:
-      'Date or period for which this metric value is recorded (e.g., day: YYYY-MM-DD, month: YYYY-MM, range: YYYY-MM-DD~YYYY-MM-DD).'
-  })
-  valueDate: string
-
-  @Column({ default: 'DAY' })
-  @Field(type => KpiPeriodType)
-  periodType: KpiPeriodType
-
-  @Column({ default: '' })
-  @Field({ nullable: true, description: 'Organizational unit for this value (project, department, company, employee, etc.)' })
-  org?: string
-
-  @Column({ type: 'simple-json', nullable: true })
-  @Field(type => ScalarObject, { nullable: true })
-  meta?: any
-
-  @CreateDateColumn()
-  @Field({ nullable: true })
-  createdAt?: Date
-
-  @UpdateDateColumn()
-  @Field({ nullable: true })
-  updatedAt?: Date
-
-  @ManyToOne(() => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  creator?: User
-
-  @RelationId((entity: KpiMetricValue) => entity.creator)
-  @Field({ nullable: true })
-  creatorId?: string
-
-  @ManyToOne(() => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  updater?: User
-
-  @RelationId((entity: KpiMetricValue) => entity.updater)
-  @Field({ nullable: true })
-  updaterId?: string
-}

package/server/service/kpi-org-scope/index.ts

@@ -1,6 +0,0 @@
-import { KpiOrgScope } from './kpi-org-scope'
-import { KpiOrgScopeQuery } from './kpi-org-scope-query'
-import { KpiOrgScopeMutation } from './kpi-org-scope-mutation'
-
-export const entities = [KpiOrgScope]
-export const resolvers = [KpiOrgScopeQuery, KpiOrgScopeMutation]