@dssp/project 0.0.9 → 0.0.11

package/server/service/construction-detail-type/construction-detail-type-query.ts

@@ -0,0 +1,31 @@
+import { Resolver, Query, FieldResolver, Root, Args, Ctx } from 'type-graphql'
+import { getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { ConstructionDetailType } from './construction-detail-type'
+import { ConstructionDetailTypeList } from './construction-detail-type-type'
+
+@Resolver(ConstructionDetailType)
+export class ConstructionDetailTypeQuery {
+  @Query(returns => ConstructionDetailTypeList, { description: 'To fetch multiple ConstructionDetailTypes' })
+  async constructionDetailTypes(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<ConstructionDetailTypeList> {
+    const queryBuilder = getQueryBuilderFromListParams({
+      params,
+      repository: await getRepository(ConstructionDetailType),
+      searchables: ['name']
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() constructionDetailType: ConstructionDetailType): Promise<User> {
+    return await getRepository(User).findOneBy({ id: constructionDetailType.updaterId })
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() constructionDetailType: ConstructionDetailType): Promise<User> {
+    return await getRepository(User).findOneBy({ id: constructionDetailType.creatorId })
+  }
+}

package/server/service/construction-detail-type/construction-detail-type-type.ts

@@ -0,0 +1,26 @@
+import { ObjectType, Field, InputType, Int, ID } from 'type-graphql'
+import { ConstructionDetailType } from './construction-detail-type'
+
+@InputType()
+export class ConstructionDetailTypePatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field(type => Int, { nullable: true })
+  sequence?: number
+
+  @Field({ nullable: true })
+  cuFlag?: string
+}
+
+@ObjectType()
+export class ConstructionDetailTypeList {
+  @Field(type => [ConstructionDetailType])
+  items: ConstructionDetailType[]
+
+  @Field(type => Int)
+  total: number
+}

package/server/service/construction-detail-type/construction-detail-type.ts

@@ -0,0 +1,52 @@
+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 { ConstructionType } from '../construction-type/construction-type'
+
+@Entity()
+@Index('ix_construction_detail_type_0', (constructionDetailType: ConstructionDetailType) => [constructionDetailType.sequence])
+@ObjectType({ description: '세부 공종 타입' })
+export class ConstructionDetailType {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @Column({ nullable: false, comment: '세부 공종 이름' })
+  @Field({ nullable: true })
+  name?: string
+
+  @Column({ nullable: true, comment: '시퀀스' })
+  @Field(type => Int, { nullable: true })
+  sequence?: number
+
+  // 공종 타입 (상위 테이블 참조)
+  @ManyToOne(type => ConstructionType)
+  @Field({ nullable: true })
+  constructionType?: ConstructionType
+
+  @RelationId((constructionDetailType: ConstructionDetailType) => constructionDetailType.constructionType)
+  constructionTypeId?: 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((constructionDetailType: ConstructionDetailType) => constructionDetailType.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId((constructionDetailType: ConstructionDetailType) => constructionDetailType.updater)
+  updaterId?: string
+}

package/server/service/construction-detail-type/index.ts

@@ -0,0 +1,6 @@
+import { ConstructionDetailType } from './construction-detail-type'
+import { ConstructionDetailTypeQuery } from './construction-detail-type-query'
+import { ConstructionDetailTypeMutation } from './construction-detail-type-mutation'
+
+export const entities = [ConstructionDetailType]
+export const resolvers = [ConstructionDetailTypeQuery, ConstructionDetailTypeMutation]

package/server/service/construction-type/construction-type-query.ts

@@ -3,6 +3,7 @@ import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from
 import { User } from '@things-factory/auth-base'
 import { ConstructionType } from './construction-type'
 import { ConstructionTypeList } from './construction-type-type'
+import { ConstructionDetailType } from '../construction-detail-type/construction-detail-type'
 
 @Resolver(ConstructionType)
 export class ConstructionTypeQuery {
@@ -30,6 +31,14 @@ export class ConstructionTypeQuery {
     return { items, total }
   }
 
+  @FieldResolver(type => [ConstructionDetailType])
+  async constructionDetailTypes(@Root() constructionType: ConstructionType): Promise<ConstructionDetailType[]> {
+    return await getRepository(ConstructionDetailType).find({
+      where: { constructionType: { id: constructionType.id } },
+      order: { sequence: 'ASC' }
+    })
+  }
+
   @FieldResolver(type => Domain)
   async domain(@Root() constructionType: ConstructionType): Promise<Domain> {
     return await getRepository(Domain).findOneBy({ id: constructionType.domainId })

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

@@ -7,12 +7,13 @@ import {
   Column,
   RelationId,
   ManyToOne,
-  PrimaryGeneratedColumn
+  PrimaryGeneratedColumn,
+  OneToMany
 } from 'typeorm'
 import { ObjectType, Field, ID } from 'type-graphql'
-
 import { Domain } from '@things-factory/shell'
 import { User } from '@things-factory/auth-base'
+import { ConstructionDetailType } from '../construction-detail-type/construction-detail-type'
 
 @Entity()
 @Index('ix_construction_type_0', (constructionType: ConstructionType) => [constructionType.domain, constructionType.name], {
@@ -40,6 +41,11 @@ export class ConstructionType {
   @Field({ nullable: true })
   description?: string
 
+  // 상세 공종 정보 (하위 테이블 참조)
+  @Field(() => [ConstructionDetailType], { nullable: true })
+  @OneToMany(() => ConstructionDetailType, constructionDetailType => constructionDetailType.constructionType)
+  constructionDetailTypes?: ConstructionDetailType[]
+
   @CreateDateColumn()
   @Field({ nullable: true })
   createdAt?: Date

package/server/service/index.ts

@@ -1,28 +1,40 @@
 /* EXPORT ENTITY TYPES */
+export * from './task-resource/task-resource'
+export * from './resource/resource'
+export * from './construction-detail-type/construction-detail-type'
 export * from './construction-type/construction-type'
+export * from './inspection-drawing-type/inspection-drawing-type'
+export * from './inspection-part/inspection-part'
 export * from './worker-type/worker-type'
 export * from './manager/manager'
-export * from './check-item/check-item'
-export * from './checklist/checklist'
 export * from './task/task'
 export * from './project/project'
 
 /* IMPORT ENTITIES AND RESOLVERS */
+import { entities as TaskResourceEntities, resolvers as TaskResourceResolvers } from './task-resource'
+import { entities as ResourceEntities, resolvers as ResourceResolvers } from './resource'
+import {
+  entities as ConstructionDetailTypeEntities,
+  resolvers as ConstructionDetailTypeResolvers
+} from './construction-detail-type'
 import { entities as ConstructionTypeEntities, resolvers as ConstructionTypeResolvers } from './construction-type'
+import { entities as InspectionDrawingTypeEntities, resolvers as InspectionDrawingTypeResolvers } from './inspection-drawing-type'
+import { entities as InspectionPartEntities, resolvers as InspectionPartResolvers } from './inspection-part'
 import { entities as WorkerTypeEntities, resolvers as WorkerTypeResolvers } from './worker-type'
 import { entities as ManagerEntities, resolvers as ManagerResolvers } from './manager'
-import { entities as CheckItemEntities, resolvers as CheckItemResolvers } from './check-item'
-import { entities as ChecklistEntities, resolvers as ChecklistResolvers } from './checklist'
 import { entities as TaskEntities, resolvers as TaskResolvers } from './task'
-import { entities as ProjectEntities, resolvers as ProjectResolvers, types as ProjectTypes } from './project'
+import { entities as ProjectEntities, resolvers as ProjectResolvers } from './project'
 
 export const entities = [
   /* ENTITIES */
+  ...TaskResourceEntities,
+  ...ResourceEntities,
+  ...ConstructionDetailTypeEntities,
   ...ConstructionTypeEntities,
+  ...InspectionDrawingTypeEntities,
+  ...InspectionPartEntities,
   ...WorkerTypeEntities,
   ...ManagerEntities,
-  ...CheckItemEntities,
-  ...ChecklistEntities,
   ...TaskEntities,
   ...ProjectEntities
 ]
@@ -30,14 +42,15 @@ export const entities = [
 export const schema = {
   resolverClasses: [
     /* RESOLVER CLASSES */
+    ...TaskResourceResolvers,
+    ...ResourceResolvers,
+    ...ConstructionDetailTypeResolvers,
     ...ConstructionTypeResolvers,
+    ...InspectionDrawingTypeResolvers,
+    ...InspectionPartResolvers,
     ...WorkerTypeResolvers,
     ...ManagerResolvers,
-    ...CheckItemResolvers,
-    ...ChecklistResolvers,
     ...TaskResolvers,
     ...ProjectResolvers
   ]
 }
-
-export const types = [...ProjectTypes]

package/server/service/inspection-drawing-type/index.ts

@@ -0,0 +1,6 @@
+import { InspectionDrawingType } from './inspection-drawing-type'
+import { InspectionDrawingTypeQuery } from './inspection-drawing-type-query'
+import { InspectionDrawingTypeMutation } from './inspection-drawing-type-mutation'
+
+export const entities = [InspectionDrawingType]
+export const resolvers = [InspectionDrawingTypeQuery, InspectionDrawingTypeMutation]

package/server/service/inspection-drawing-type/inspection-drawing-type-mutation.ts

@@ -0,0 +1,69 @@
+import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
+import { In } from 'typeorm'
+import { getRepository } from '@things-factory/shell'
+import { InspectionDrawingType } from './inspection-drawing-type'
+import { InspectionDrawingTypePatch } from './inspection-drawing-type-type'
+
+@Resolver(InspectionDrawingType)
+export class InspectionDrawingTypeMutation {
+  @Directive('@transaction')
+  @Mutation(returns => [InspectionDrawingType], { description: "To modify multiple InspectionDrawingTypes' information" })
+  async updateMultipleInspectionDrawingType(
+    @Arg('patches', type => [InspectionDrawingTypePatch]) patches: InspectionDrawingTypePatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<InspectionDrawingType[]> {
+    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 inspectionDrawingTypeRepo = getRepository(InspectionDrawingType, tx)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await inspectionDrawingTypeRepo.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 inspectionDrawingType = await inspectionDrawingTypeRepo.findOneBy({ id: updateRecord.id })
+
+        const result = await inspectionDrawingTypeRepo.save({
+          ...inspectionDrawingType,
+          ...updateRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple InspectionDrawingTypes' })
+  async deleteInspectionDrawingTypes(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await getRepository(InspectionDrawingType, tx).delete({
+      id: In(ids)
+    })
+
+    return true
+  }
+}

package/server/service/inspection-drawing-type/inspection-drawing-type-query.ts

@@ -0,0 +1,55 @@
+import { Resolver, Query, FieldResolver, Root, Args, Arg, Ctx, Directive } from 'type-graphql'
+import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { InspectionDrawingType } from './inspection-drawing-type'
+import { InspectionDrawingTypeList } from './inspection-drawing-type-type'
+import { InspectionPart } from '../inspection-part/inspection-part'
+
+@Resolver(InspectionDrawingType)
+export class InspectionDrawingTypeQuery {
+  @Query(returns => InspectionDrawingType!, { nullable: true, description: 'To fetch a InspectionDrawingType' })
+  async inspectionDrawingType(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<InspectionDrawingType> {
+    const { domain } = context.state
+
+    return await getRepository(InspectionDrawingType).findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+  }
+
+  @Query(returns => InspectionDrawingTypeList, { description: 'To fetch multiple InspectionDrawingTypes' })
+  async inspectionDrawingTypes(
+    @Args(type => ListParam) params: ListParam,
+    @Ctx() context: ResolverContext
+  ): Promise<InspectionDrawingTypeList> {
+    const { domain } = context.state
+
+    const queryBuilder = getQueryBuilderFromListParams({
+      domain,
+      params,
+      repository: await getRepository(InspectionDrawingType),
+      searchables: ['name']
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => [InspectionPart])
+  async inspectionParts(@Root() inspectionDrawingType: InspectionDrawingType): Promise<InspectionPart[]> {
+    return await getRepository(InspectionPart).find({
+      where: { inspectionDrawingType: { id: inspectionDrawingType.id } },
+      order: { sequence: 'ASC' }
+    })
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() inspectionDrawingType: InspectionDrawingType): Promise<User> {
+    return inspectionDrawingType.updaterId && (await getRepository(User).findOneBy({ id: inspectionDrawingType.updaterId }))
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() inspectionDrawingType: InspectionDrawingType): Promise<User> {
+    return inspectionDrawingType.creatorId && (await getRepository(User).findOneBy({ id: inspectionDrawingType.creatorId }))
+  }
+}

package/server/service/inspection-drawing-type/inspection-drawing-type-type.ts

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

package/server/service/inspection-drawing-type/inspection-drawing-type.ts

@@ -0,0 +1,68 @@
+import {
+  CreateDateColumn,
+  UpdateDateColumn,
+  Entity,
+  Index,
+  Column,
+  RelationId,
+  ManyToOne,
+  OneToMany,
+  PrimaryGeneratedColumn
+} from 'typeorm'
+import { ObjectType, Field, ID } from 'type-graphql'
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+import { InspectionPart } from '../inspection-part/inspection-part'
+
+@Entity()
+@Index(
+  'ix_inspection_drawing_type_0',
+  (inspectionDrawingType: InspectionDrawingType) => [inspectionDrawingType.domain, inspectionDrawingType.name],
+  {
+    unique: true
+  }
+)
+@ObjectType({ description: 'Entity for InspectionDrawingType' })
+export class InspectionDrawingType {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field({ nullable: true })
+  domain?: Domain
+
+  @RelationId((inspectionDrawingType: InspectionDrawingType) => inspectionDrawingType.domain)
+  domainId?: string
+
+  @Column({ nullable: false, comment: '검측 도면 타입 이름' })
+  @Field({ nullable: true })
+  name?: string
+
+  // 검측 부위 정보 (하위 테이블 참조)
+  @Field(() => [InspectionPart], { nullable: true })
+  @OneToMany(() => InspectionPart, inspectionPart => inspectionPart.inspectionDrawingType)
+  inspectionParts?: InspectionPart[]
+
+  @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((inspectionDrawingType: InspectionDrawingType) => inspectionDrawingType.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId((inspectionDrawingType: InspectionDrawingType) => inspectionDrawingType.updater)
+  updaterId?: string
+}

package/server/service/inspection-part/index.ts

@@ -0,0 +1,6 @@
+import { InspectionPart } from './inspection-part'
+import { InspectionPartQuery } from './inspection-part-query'
+import { InspectionPartMutation } from './inspection-part-mutation'
+
+export const entities = [InspectionPart]
+export const resolvers = [InspectionPartQuery, InspectionPartMutation]

package/server/service/inspection-part/inspection-part-mutation.ts

@@ -0,0 +1,52 @@
+import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
+import { In } from 'typeorm'
+import { getRepository } from '@things-factory/shell'
+import { InspectionPart } from './inspection-part'
+import { InspectionPartPatch } from './inspection-part-type'
+import { InspectionDrawingType } from '../inspection-drawing-type/inspection-drawing-type'
+
+@Resolver(InspectionPart)
+export class InspectionPartMutation {
+  @Directive('@transaction')
+  @Mutation(returns => [InspectionPart], { description: "To modify multiple InspectionParts' information" })
+  async updateMultipleInspectionPart(
+    @Arg('patches', type => [InspectionPartPatch]) patches: InspectionPartPatch[],
+    @Arg('inspectionDrawingTypeId') inspectionDrawingTypeId: string,
+    @Ctx() context: ResolverContext
+  ): Promise<InspectionPart[]> {
+    const { user, tx } = context.state
+
+    let results = []
+
+    const inspectionPartRepo = tx.getRepository(InspectionPart)
+    const inspectionDrawingType = await tx.getRepository(InspectionDrawingType).findOneBy({ id: inspectionDrawingTypeId })
+
+    await inspectionPartRepo.delete({ inspectionDrawingType: { id: inspectionDrawingTypeId } })
+
+    for (let i = 0; i < patches.length; i++) {
+      const result = await inspectionPartRepo.save({
+        ...patches[i],
+        sequence: i,
+        inspectionDrawingType,
+        creator: user,
+        updater: user
+      })
+
+      results.push({ ...result, cuFlag: '+' })
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple InspectionParts' })
+  async deleteInspectionParts(@Arg('ids', type => [String]) ids: string[], @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await getRepository(InspectionPart, tx).delete({
+      id: In(ids)
+    })
+
+    return true
+  }
+}

package/server/service/inspection-part/inspection-part-query.ts

@@ -0,0 +1,41 @@
+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 { InspectionPart } from './inspection-part'
+import { InspectionPartList } from './inspection-part-type'
+
+@Resolver(InspectionPart)
+export class InspectionPartQuery {
+  @Query(returns => InspectionPart!, { nullable: true, description: 'To fetch a InspectionPart' })
+  async inspectionPart(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<InspectionPart> {
+    return await getRepository(InspectionPart).findOne({
+      where: { id }
+    })
+  }
+
+  @Query(returns => InspectionPartList, { description: 'To fetch multiple InspectionParts' })
+  async inspectionParts(
+    @Args(type => ListParam) params: ListParam,
+    @Ctx() context: ResolverContext
+  ): Promise<InspectionPartList> {
+    const queryBuilder = getQueryBuilderFromListParams({
+      params,
+      repository: await getRepository(InspectionPart),
+      searchables: ['name', 'description']
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() inspectionPart: InspectionPart): Promise<User> {
+    return inspectionPart.updaterId && (await getRepository(User).findOneBy({ id: inspectionPart.updaterId }))
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() inspectionPart: InspectionPart): Promise<User> {
+    return inspectionPart.creatorId && (await getRepository(User).findOneBy({ id: inspectionPart.creatorId }))
+  }
+}

package/server/service/inspection-part/inspection-part-type.ts

@@ -0,0 +1,26 @@
+import { ObjectType, Field, InputType, Int, ID } from 'type-graphql'
+import { InspectionPart } from './inspection-part'
+
+@InputType()
+export class InspectionPartPatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field(type => Int, { nullable: true })
+  sequence?: number
+
+  @Field({ nullable: true })
+  cuFlag?: string
+}
+
+@ObjectType()
+export class InspectionPartList {
+  @Field(type => [InspectionPart])
+  items: InspectionPart[]
+
+  @Field(type => Int)
+  total: number
+}

package/server/service/inspection-part/inspection-part.ts

@@ -0,0 +1,51 @@
+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 { InspectionDrawingType } from '../inspection-drawing-type/inspection-drawing-type'
+
+@Entity()
+@Index('ix_inspection_part_0', (inspectionPart: InspectionPart) => [inspectionPart.sequence])
+@ObjectType({ description: 'Entity for InspectionPart' })
+export class InspectionPart {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @Column({ nullable: false, comment: '검측 부위' })
+  @Field({ nullable: true })
+  name?: string
+
+  @Column({ nullable: true, comment: '시퀀스' })
+  @Field(type => Int, { nullable: true })
+  sequence?: number
+
+  // 검측 도면 정보 (상위 테이블 참조)
+  @ManyToOne(type => InspectionDrawingType)
+  @Field(type => InspectionDrawingType, { nullable: true })
+  inspectionDrawingType?: InspectionDrawingType
+
+  @RelationId((inspectionPart: InspectionPart) => inspectionPart.inspectionDrawingType)
+  inspectionDrawingTypeId?: 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((inspectionPart: InspectionPart) => inspectionPart.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId((inspectionPart: InspectionPart) => inspectionPart.updater)
+  updaterId?: string
+}

package/server/service/project/index.ts

@@ -1,8 +1,6 @@
 import { Project } from './project'
 import { ProjectQuery } from './project-query'
 import { ProjectMutation } from './project-mutation'
-import { InspectionSummary } from './project-type'
 
 export const entities = [Project]
 export const resolvers = [ProjectQuery, ProjectMutation]
-export const types = [InspectionSummary]