@dssp/supervision 1.0.0-alpha.0 → 1.0.0-alpha.2

package/server/service/checklist-item-comment/checklist-item-comment-mutation.ts

@@ -1,80 +0,0 @@
-import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
-import { getRepository } from '@things-factory/shell'
-import { ChecklistItemComment } from './checklist-item-comment'
-import { NewChecklistItemComment, ChecklistItemCommentPatch } from './checklist-item-comment-type'
-import { BuildingInspectionStatus } from '../building-inspection/building-inspection'
-import { ChecklistItemQuery } from '../checklist-item/checklist-item-query'
-
-@Resolver(ChecklistItemComment)
-export class ChecklistItemCommentMutation {
-  @Directive('@transaction')
-  @Mutation(returns => ChecklistItemComment, { description: 'To create new ChecklistItemComment' })
-  async createChecklistItemComment(
-    @Arg('checklistItemComment') checklistItemComment: NewChecklistItemComment,
-    @Ctx() context: ResolverContext
-  ): Promise<ChecklistItemComment> {
-    const { user, tx } = context.state
-    const { comment, checklistItemId } = checklistItemComment
-
-    // 합격 상태인지 체크
-    const checklistItemQuery = new ChecklistItemQuery()
-    const inspection = await checklistItemQuery.inspectionByChecklistItemId(checklistItemId)
-    if (inspection.status === BuildingInspectionStatus.PASS) {
-      throw new Error('완료 상태인 검측정보를 변경할 수 없습니다.')
-    }
-
-    const result = await getRepository(ChecklistItemComment, tx).save({
-      comment,
-      checklistItem: { id: checklistItemId },
-      createdAt: new Date(),
-      creator: user,
-      updater: user
-    })
-
-    return result
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => ChecklistItemComment, { description: 'To modify ChecklistItemComment information' })
-  async updateChecklistItemComment(
-    @Arg('id') id: string,
-    @Arg('patch') patch: ChecklistItemCommentPatch,
-    @Ctx() context: ResolverContext
-  ): Promise<ChecklistItemComment> {
-    const { user, tx } = context.state
-
-    const repository = getRepository(ChecklistItemComment, tx)
-    const checklistItemComment = await repository.findOne({
-      where: { id }
-    })
-
-    const result = await repository.save({
-      ...checklistItemComment,
-      ...patch,
-      updater: user
-    })
-
-    return result
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete ChecklistItemComment' })
-  async deleteChecklistItemComment(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { tx } = context.state
-    const repository = getRepository(ChecklistItemComment, tx)
-    const checklistItemComment = await repository.findOne({
-      where: { id }
-    })
-
-    // 합격 상태인지 체크
-    const checklistItemQuery = new ChecklistItemQuery()
-    const inspection = await checklistItemQuery.inspectionByChecklistItemId(checklistItemComment.checklistItemId)
-    if (inspection.status === BuildingInspectionStatus.PASS) {
-      throw new Error('완료 상태인 검측정보를 변경할 수 없습니다.')
-    }
-
-    await repository.softDelete({ id })
-
-    return true
-  }
-}

package/server/service/checklist-item-comment/checklist-item-comment-query.ts

@@ -1,36 +0,0 @@
-import { Resolver, Query, FieldResolver, Root, Arg, Ctx } from 'type-graphql'
-import { getRepository, Pagination } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-import { ChecklistItemComment } from './checklist-item-comment'
-
-@Resolver(ChecklistItemComment)
-export class ChecklistItemCommentQuery {
-  @Query(returns => [ChecklistItemComment], { description: 'To fetch multiple ChecklistItemComments' })
-  async checklistItemComments(
-    @Arg('checklistItemId') checklistItemId: string,
-    @Arg('pagination') pagination: Pagination,
-    @Ctx() context: ResolverContext
-  ): Promise<ChecklistItemComment[]> {
-    const { limit, page } = pagination
-
-    // 페이지네이션을 위한 offset 계산
-    const offset = (page - 1) * limit
-
-    // 코멘트와 총 개수를 가져오는 쿼리
-    const items = await getRepository(ChecklistItemComment)
-      .createQueryBuilder('cic')
-      .innerJoin('cic.checklistItem', 'ci')
-      .where('cic.checklistItem = :checklistItemId', { checklistItemId })
-      .skip(offset)
-      .take(limit)
-      .orderBy('cic.createdAt', 'DESC')
-      .getMany()
-
-    return items
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() checklistItemComment: ChecklistItemComment): Promise<User> {
-    return checklistItemComment.creatorId && (await getRepository(User).findOneBy({ id: checklistItemComment.creatorId }))
-  }
-}

package/server/service/checklist-item-comment/checklist-item-comment-type.ts

@@ -1,32 +0,0 @@
-import { ObjectType, Field, InputType, Int, ID } from 'type-graphql'
-import { ChecklistItemComment } from './checklist-item-comment'
-
-@InputType()
-export class NewChecklistItemComment {
-  @Field({ nullable: true })
-  comment?: string
-
-  @Field({ nullable: true })
-  checklistItemId?: string
-}
-
-@InputType()
-export class ChecklistItemCommentPatch {
-  @Field(type => ID, { nullable: true })
-  id?: string
-
-  @Field({ nullable: true })
-  comment?: string
-
-  @Field({ nullable: true })
-  checklistItemId?: string
-}
-
-@ObjectType()
-export class ChecklistItemCommentList {
-  @Field(type => [ChecklistItemComment])
-  items: ChecklistItemComment[]
-
-  @Field(type => Int)
-  total: number
-}

package/server/service/checklist-item-comment/checklist-item-comment.ts

@@ -1,56 +0,0 @@
-import {
-  CreateDateColumn,
-  UpdateDateColumn,
-  DeleteDateColumn,
-  Entity,
-  Index,
-  Column,
-  RelationId,
-  ManyToOne,
-  PrimaryGeneratedColumn
-} from 'typeorm'
-import { ObjectType, Field, ID } from 'type-graphql'
-import { User } from '@things-factory/auth-base'
-import { ChecklistItem } from '../checklist-item/checklist-item'
-
-@Entity()
-@Index(
-  'ix_checklist_item_comment_0',
-  (checklistItemComment: ChecklistItemComment) => [checklistItemComment.checklistItem, checklistItemComment.createdAt],
-  {
-    where: '"deleted_at" IS NULL'
-  }
-)
-@ObjectType({ description: 'Entity for ChecklistItemComment' })
-export class ChecklistItemComment {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id: string
-
-  @Column({ nullable: true, comment: '조치 사항 코멘트' })
-  @Field({ nullable: true })
-  comment?: string
-
-  // 체크리스트 아이템 정보 (상위 테이블 참조)
-  @ManyToOne(type => ChecklistItem)
-  @Field(type => ChecklistItem, { nullable: true })
-  checklistItem?: ChecklistItem
-
-  @RelationId((checklistItemComment: ChecklistItemComment) => checklistItemComment.checklistItem)
-  checklistItemId?: string
-
-  @CreateDateColumn()
-  @Field({ nullable: true })
-  createdAt?: Date
-
-  @DeleteDateColumn()
-  @Field({ nullable: true })
-  deletedAt?: Date
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  creator?: User
-
-  @RelationId((checklistItemComment: ChecklistItemComment) => checklistItemComment.creator)
-  creatorId?: string
-}

package/server/service/checklist-item-comment/event-subscriber.ts

@@ -1,17 +0,0 @@
-import { EventSubscriber } from 'typeorm'
-
-import { HistoryEntitySubscriber } from '@operato/typeorm-history'
-
-import { ChecklistItemComment } from './checklist-item-comment'
-import { ChecklistItemCommentHistory } from './checklist-item-comment-history'
-
-@EventSubscriber()
-export class ChecklistItemCommentHistoryEntitySubscriber extends HistoryEntitySubscriber<ChecklistItemComment, ChecklistItemCommentHistory> {
-  public get entity() {
-    return ChecklistItemComment
-  }
-
-  public get historyEntity() {
-    return ChecklistItemCommentHistory
-  }
-}

package/server/service/checklist-item-comment/index.ts

@@ -1,9 +0,0 @@
-import { ChecklistItemComment } from './checklist-item-comment'
-import { ChecklistItemCommentHistory } from './checklist-item-comment-history'
-import { ChecklistItemCommentHistoryEntitySubscriber } from './event-subscriber'
-import { ChecklistItemCommentQuery } from './checklist-item-comment-query'
-import { ChecklistItemCommentMutation } from './checklist-item-comment-mutation'
-
-export const entities = [ChecklistItemComment, ChecklistItemCommentHistory]
-export const resolvers = [ChecklistItemCommentQuery, ChecklistItemCommentMutation]
-export const subscribers = [ChecklistItemCommentHistoryEntitySubscriber]

package/server/service/checklist-template/checklist-template-mutation.ts

@@ -1,66 +0,0 @@
-import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
-import { In } from 'typeorm'
-import { ChecklistTemplate } from './checklist-template'
-import { ChecklistTemplatePatch } from './checklist-template-type'
-
-@Resolver(ChecklistTemplate)
-export class ChecklistTemplateMutation {
-  @Directive('@transaction')
-  @Mutation(returns => [ChecklistTemplate], { description: "To modify multiple ChecklistTemplates' information" })
-  async updateMultipleChecklistTemplate(
-    @Arg('patches', type => [ChecklistTemplatePatch]) patches: ChecklistTemplatePatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<ChecklistTemplate[]> {
-    const { domain, user, tx } = context.state
-
-    let results = []
-    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
-    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
-    const checklistTemplateRepo = tx.getRepository(ChecklistTemplate)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        const result = await checklistTemplateRepo.save({
-          ...newRecord,
-          domain,
-          creator: user,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: '+' })
-      }
-    }
-
-    if (_updateRecords.length > 0) {
-      for (let i = 0; i < _updateRecords.length; i++) {
-        const updateRecord = _updateRecords[i]
-        const checklistTemplate = await checklistTemplateRepo.findOneBy({ id: updateRecord.id })
-
-        const result = await checklistTemplateRepo.save({
-          ...checklistTemplate,
-          ...updateRecord,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete multiple ChecklistTemplates' })
-  async deleteChecklistTemplates(@Arg('ids', type => [String]) ids: string[], @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(ChecklistTemplate).delete({
-      domain: { id: domain.id },
-      id: In(ids)
-    })
-
-    return true
-  }
-}

package/server/service/checklist-template/checklist-template-query.ts

@@ -1,39 +0,0 @@
-import { Resolver, Query, FieldResolver, Root, Args, Ctx } from 'type-graphql'
-import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-import { ChecklistTemplate } from './checklist-template'
-import { ChecklistTemplateList } from './checklist-template-type'
-
-@Resolver(ChecklistTemplate)
-export class ChecklistTemplateQuery {
-  @Query(returns => ChecklistTemplateList, { description: 'To fetch multiple ChecklistTemplates' })
-  async checklistTemplates(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<ChecklistTemplateList> {
-    const { domain } = context.state
-
-    const queryBuilder = getQueryBuilderFromListParams({
-      domain,
-      params,
-      repository: await getRepository(ChecklistTemplate),
-      searchables: ['name']
-    })
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() checklistTemplate: ChecklistTemplate): Promise<Domain> {
-    return await getRepository(Domain).findOneBy({ id: checklistTemplate.domainId })
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() checklistTemplate: ChecklistTemplate): Promise<User> {
-    return await getRepository(User).findOneBy({ id: checklistTemplate.updaterId })
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() checklistTemplate: ChecklistTemplate): Promise<User> {
-    return await getRepository(User).findOneBy({ id: checklistTemplate.creatorId })
-  }
-}

package/server/service/checklist-template/checklist-template-type.ts

@@ -1,23 +0,0 @@
-import { ObjectType, Field, InputType, Int, ID } from 'type-graphql'
-import { ChecklistTemplate } from './checklist-template'
-
-@InputType()
-export class ChecklistTemplatePatch {
-  @Field(type => ID, { nullable: true })
-  id?: string
-
-  @Field({ nullable: true })
-  name?: string
-
-  @Field({ nullable: true })
-  cuFlag?: string
-}
-
-@ObjectType()
-export class ChecklistTemplateList {
-  @Field(type => [ChecklistTemplate])
-  items: ChecklistTemplate[]
-
-  @Field(type => Int)
-  total: number
-}

package/server/service/checklist-template/checklist-template.ts

@@ -1,71 +0,0 @@
-import {
-  CreateDateColumn,
-  UpdateDateColumn,
-  DeleteDateColumn,
-  Entity,
-  Index,
-  Column,
-  RelationId,
-  ManyToOne,
-  OneToMany,
-  PrimaryGeneratedColumn
-} from 'typeorm'
-import { ObjectType, Field, ID } from 'type-graphql'
-
-import { Domain } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-import { ChecklistTemplateItem } from '../checklist-template-item/checklist-template-item'
-
-@Entity({ comment: '체크리스트 템플릿' })
-@Index('ix_checklist_template_0', (checklistTemplate: ChecklistTemplate) => [checklistTemplate.domain, checklistTemplate.name], {
-  unique: true,
-  where: '"deleted_at" IS NULL'
-})
-@ObjectType()
-export class ChecklistTemplate {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id: string
-
-  @ManyToOne(type => Domain)
-  @Field({ nullable: true })
-  domain?: Domain
-
-  @RelationId((checklistTemplate: ChecklistTemplate) => checklistTemplate.domain)
-  domainId?: string
-
-  @Column({ nullable: true, comment: '이름' })
-  @Field({ nullable: true })
-  name?: string
-
-  // 체크리스트 템플릿 아이템 정보 (하위 테이블 참조)
-  @Field(() => [ChecklistTemplateItem])
-  @OneToMany(() => ChecklistTemplateItem, checklistTemplateItem => checklistTemplateItem.checklistTemplate)
-  checklistTemplateItems?: ChecklistTemplateItem[]
-
-  @CreateDateColumn()
-  @Field({ nullable: true })
-  createdAt?: Date
-
-  @UpdateDateColumn()
-  @Field({ nullable: true })
-  updatedAt?: Date
-
-  @DeleteDateColumn()
-  @Field({ nullable: true })
-  deletedAt?: Date
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  creator?: User
-
-  @RelationId((checklistTemplate: ChecklistTemplate) => checklistTemplate.creator)
-  creatorId?: string
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  updater?: User
-
-  @RelationId((checklistTemplate: ChecklistTemplate) => checklistTemplate.updater)
-  updaterId?: string
-}

package/server/service/checklist-template/index.ts

@@ -1,6 +0,0 @@
-import { ChecklistTemplate } from './checklist-template'
-import { ChecklistTemplateQuery } from './checklist-template-query'
-import { ChecklistTemplateMutation } from './checklist-template-mutation'
-
-export const entities = [ChecklistTemplate]
-export const resolvers = [ChecklistTemplateQuery, ChecklistTemplateMutation]

package/server/service/checklist-template-item/checklist-template-item-mutation.ts

@@ -1,64 +0,0 @@
-import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
-import { In } from 'typeorm'
-import { ChecklistTemplateItem } from './checklist-template-item'
-import { ChecklistTemplateItemPatch } from './checklist-template-item-type'
-import { ChecklistTemplate } from '../checklist-template/checklist-template'
-
-@Resolver(ChecklistTemplateItem)
-export class ChecklistTemplateItemMutation {
-  @Directive('@transaction')
-  @Mutation(returns => [ChecklistTemplateItem], { description: "To modify multiple ChecklistTemplateItems' information" })
-  async updateMultipleChecklistTemplateItems(
-    @Arg('patches', type => [ChecklistTemplateItemPatch]) patches: ChecklistTemplateItemPatch[],
-    @Arg('checklistTemplateId') checklistTemplateId: string,
-    @Ctx() context: ResolverContext
-  ): Promise<ChecklistTemplateItem[]> {
-    const { domain, user, tx } = context.state
-
-    let results = []
-
-    const checklistTemplateItemRepo = tx.getRepository(ChecklistTemplateItem)
-    const checklistTemplate = await tx.getRepository(ChecklistTemplate).findOneBy({ id: checklistTemplateId })
-
-    await checklistTemplateItemRepo.delete({ checklistTemplate: { id: checklistTemplateId } })
-
-    for (let i = 0; i < patches.length; i++) {
-      const result = await checklistTemplateItemRepo.save({
-        ...patches[i],
-        sequence: i,
-        checklistTemplate,
-        creator: user,
-        updater: user
-      })
-
-      results.push({ ...result, cuFlag: '+' })
-    }
-
-    return results
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete ChecklistTemplateItem' })
-  async deleteChecklistTemplateItem(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(ChecklistTemplateItem).delete({ id })
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete multiple ChecklistTemplateItems' })
-  async deleteChecklistTemplateItems(
-    @Arg('ids', type => [String]) ids: string[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(ChecklistTemplateItem).delete({
-      id: In(ids)
-    })
-
-    return true
-  }
-}

package/server/service/checklist-template-item/checklist-template-item-query.ts

@@ -1,44 +0,0 @@
-import { Resolver, Query, FieldResolver, Root, Args, Arg, Ctx } from 'type-graphql'
-import { getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-import { ChecklistTemplateItem } from './checklist-template-item'
-import { ChecklistTemplateItemList } from './checklist-template-item-type'
-import { ChecklistType } from '../checklist-type/checklist-type'
-
-@Resolver(ChecklistTemplateItem)
-export class ChecklistTemplateItemQuery {
-  @Query(returns => ChecklistTemplateItem!, { nullable: true, description: 'To fetch a ChecklistTemplateItem' })
-  async checklistTemplateItem(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<ChecklistTemplateItem> {
-    return await getRepository(ChecklistTemplateItem).findOne({
-      where: { id }
-    })
-  }
-
-  @Query(returns => ChecklistTemplateItemList, { description: 'To fetch multiple ChecklistTemplateItems' })
-  async checklistTemplateItems(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<ChecklistTemplateItemList> {
-    const queryBuilder = getQueryBuilderFromListParams({
-      params,
-      repository: await getRepository(ChecklistTemplateItem),
-      searchables: ['name', 'description']
-    })
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-
-  @FieldResolver(type => String)
-  async detailTypeName(@Root() checklistTemplateItem: ChecklistTemplateItem): Promise<string> {
-    return (await getRepository(ChecklistType).findOneBy({ id: checklistTemplateItem.detailType }))?.detailType || ''
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() checklistTemplateItem: ChecklistTemplateItem): Promise<User> {
-    return await getRepository(User).findOneBy({ id: checklistTemplateItem.updaterId })
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() checklistTemplateItem: ChecklistTemplateItem): Promise<User> {
-    return await getRepository(User).findOneBy({ id: checklistTemplateItem.creatorId })
-  }
-}

package/server/service/checklist-template-item/checklist-template-item-type.ts

@@ -1,39 +0,0 @@
-import { ObjectType, Field, InputType, Int, ID } from 'type-graphql'
-import { ChecklistTemplateItem } from './checklist-template-item'
-import { ChecklistTypeMainType } from '../checklist-type/checklist-type'
-
-@InputType()
-export class ChecklistTemplateItemPatch {
-  @Field(type => ID, { nullable: true })
-  id?: string
-
-  @Field({ nullable: true })
-  name?: string
-
-  @Field({ nullable: true })
-  inspctionCriteria?: string
-
-  @Field(type => Int, { nullable: true })
-  sequence?: number
-
-  @Field({ nullable: true })
-  mainType?: ChecklistTypeMainType
-
-  @Field({ nullable: true })
-  detailType?: string
-
-  @Field({ nullable: true })
-  checklistTemplateId?: string
-
-  @Field({ nullable: true })
-  cuFlag?: string
-}
-
-@ObjectType()
-export class ChecklistTemplateItemList {
-  @Field(type => [ChecklistTemplateItem])
-  items: ChecklistTemplateItem[]
-
-  @Field(type => Int)
-  total: number
-}

package/server/service/checklist-template-item/checklist-template-item.ts

@@ -1,68 +0,0 @@
-import { CreateDateColumn, UpdateDateColumn, Entity, Index, Column, RelationId, ManyToOne, PrimaryGeneratedColumn } from 'typeorm'
-import { ObjectType, Field, ID, Int } from 'type-graphql'
-
-import { User } from '@things-factory/auth-base'
-import { ChecklistTemplate } from '../checklist-template/checklist-template'
-import { ChecklistTypeMainType } from '../checklist-type/checklist-type'
-
-@Entity({ comment: '체크리스트 템플릿 아이템' })
-@Index('ix_checklist_template_item_0', (checklistTemplateItem: ChecklistTemplateItem) => [checklistTemplateItem.name], {
-  unique: true
-})
-@Index('ix_checklist_template_item_1', (checklistTemplateItem: ChecklistTemplateItem) => [checklistTemplateItem.detailType])
-@ObjectType()
-export class ChecklistTemplateItem {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id: string
-
-  @Column({ nullable: false, comment: '검사 항목' })
-  @Field({ nullable: false })
-  name: string
-
-  @Column({ nullable: true, comment: '검사 기준' })
-  @Field({ nullable: true })
-  inspctionCriteria?: string
-
-  @Column({ nullable: true, comment: '시퀀스' })
-  @Field(type => Int, { nullable: true })
-  sequence?: number
-
-  @Column({ nullable: false, comment: '메인 구분 (10: 기본 업무, 20: 기본 외 업무)' })
-  @Field({ nullable: false })
-  mainType: ChecklistTypeMainType
-
-  @Column({ nullable: false, comment: '상세 구분 ID (F.K)' })
-  @Field({ nullable: false })
-  detailType: string
-
-  // 체크리스트 템플릿 정보 (상위 테이블 참조)
-  @ManyToOne(type => ChecklistTemplate)
-  @Field(type => ChecklistTemplate, { nullable: true })
-  checklistTemplate?: ChecklistTemplate
-
-  @RelationId((checklistTemplateItem: ChecklistTemplateItem) => checklistTemplateItem.checklistTemplate)
-  checklistTemplateId?: string
-
-  @CreateDateColumn()
-  @Field({ nullable: true })
-  createdAt?: Date
-
-  @UpdateDateColumn()
-  @Field({ nullable: true })
-  updatedAt?: Date
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  creator?: User
-
-  @RelationId((checklistTemplateItem: ChecklistTemplateItem) => checklistTemplateItem.creator)
-  creatorId?: string
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  updater?: User
-
-  @RelationId((checklistTemplateItem: ChecklistTemplateItem) => checklistTemplateItem.updater)
-  updaterId?: string
-}

package/server/service/checklist-template-item/index.ts

@@ -1,6 +0,0 @@
-import { ChecklistTemplateItem } from './checklist-template-item'
-import { ChecklistTemplateItemQuery } from './checklist-template-item-query'
-import { ChecklistTemplateItemMutation } from './checklist-template-item-mutation'
-
-export const entities = [ChecklistTemplateItem]
-export const resolvers = [ChecklistTemplateItemQuery, ChecklistTemplateItemMutation]