@dssp/supervision 0.0.9 → 0.0.10

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

@@ -0,0 +1,202 @@
+import { Resolver, Query, FieldResolver, Root, Arg, Args, Ctx } from 'type-graphql'
+import { Attachment } from '@things-factory/attachment-base'
+import { getRepository, getQueryBuilderFromListParams, ListParam } from '@things-factory/shell'
+import { BuildingInspection, BuildingInspectionStatus } from './building-inspection'
+import {
+  BuildingInspectionList,
+  BuildingInspectionsOfBuildingLevel,
+  BuildingInspectionsOfProject,
+  BuildingInspectionSummary
+} from './building-inspection-type'
+import { BuildingLevel } from '@dssp/building-complex'
+import { Checklist } from '../checklist/checklist'
+import { Project } from '@dssp/project'
+
+@Resolver(BuildingInspection)
+export class BuildingInspectionQuery {
+  @Query(returns => BuildingInspection!, { nullable: true, description: 'To fetch a BuildingInspection' })
+  async buildingInspection(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<BuildingInspection> {
+    return await getRepository(BuildingInspection).findOne({
+      where: { id }
+    })
+  }
+
+  @Query(returns => BuildingInspectionList, { description: 'To fetch multiple BuildingInspections' })
+  async buildingInspections(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<BuildingInspectionList> {
+    const { domain } = context.state
+
+    const queryBuilder = getQueryBuilderFromListParams({
+      params,
+      repository: await getRepository(BuildingInspection),
+      searchables: ['name']
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @Query(returns => BuildingInspectionList, { description: 'To fetch multiple BuildingInspections' })
+  async buildingInspectionsOfProject(
+    @Arg('params') params: BuildingInspectionsOfProject,
+    @Ctx() context: ResolverContext
+  ): Promise<BuildingInspectionList> {
+    const { domain } = context.state
+    const { projectId, limit } = params
+
+    const queryBuilder = getRepository(BuildingInspection)
+      .createQueryBuilder('bi')
+      .innerJoin('building_levels', 'bl', 'bi.building_level_id = bl.id')
+      .innerJoin('buildings', 'b', 'bl.building_id = b.id')
+      .innerJoin('building_complexes', 'bc', 'b.building_complex_id = bc.id')
+      .innerJoin('projects', 'p', 'bc.id = p.building_complex_id')
+      .innerJoin('checklists', 'c', 'bi.checklist_id = c.id')
+      .where('p.domain = :domain', { domain: domain.id })
+      .andWhere('p.id = :projectId', { projectId })
+      .orderBy('bi.created_at', 'DESC')
+
+    if (limit) {
+      queryBuilder.limit(limit)
+    }
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @Query(returns => Project!, { description: 'To fetch Project' })
+  async projectByBuildingLevelId(
+    @Arg('buildingLevelId') buildingLevelId: string,
+    @Ctx() context: ResolverContext
+  ): Promise<Project> {
+    const queryBuilder = getRepository(Project)
+      .createQueryBuilder('p')
+      .innerJoin('building_complexes', 'bc', 'p.building_complex_id = bc.id')
+      .innerJoin('buildings', 'b', 'b.building_complex_id = bc.id')
+      .innerJoin('building_levels', 'bl', 'bl.building_id = b.id')
+      .where('bl.id = :buildingLevelId', { buildingLevelId })
+
+    const result = await queryBuilder.getOne()
+
+    return result
+  }
+
+  @Query(returns => BuildingInspectionList, { description: 'To fetch multiple BuildingInspections' })
+  async buildingInspectionsOfBuildingLevel(
+    @Arg('params') params: BuildingInspectionsOfBuildingLevel,
+    @Ctx() context: ResolverContext
+  ): Promise<BuildingInspectionList> {
+    const { buildingLevelId, limit } = params
+
+    const queryBuilder = getRepository(BuildingInspection)
+      .createQueryBuilder('bi')
+      .innerJoin('building_levels', 'bl', 'bi.building_level_id = bl.id')
+      .innerJoin('checklists', 'c', 'bi.checklist_id = c.id')
+      .where('bl.id = :buildingLevelId', { buildingLevelId })
+      .orderBy('bi.updated_at', 'DESC')
+
+    if (limit) {
+      queryBuilder.limit(limit)
+    }
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  // 층 별로 검수 개수 써머리
+  @Query(returns => BuildingInspectionSummary!, { nullable: true, description: 'To fetch a BuildingInspection Summary' })
+  async buildingInspectionSummaryOfBuildingLevel(
+    @Arg('buildingLevelId') buildingLevelId: string,
+    @Ctx() context: ResolverContext
+  ): Promise<BuildingInspectionSummary> {
+    const buildingInspectionSummary = await getRepository(BuildingInspection)
+      .createQueryBuilder('bi')
+      .select(`COUNT(CASE WHEN bi.status='${BuildingInspectionStatus.WAIT}' THEN 1 ELSE NULL END) AS wait`)
+      .addSelect(`COUNT(CASE WHEN bi.status='${BuildingInspectionStatus.REQUEST}' THEN 1 ELSE NULL END) AS request`)
+      .addSelect(`COUNT(CASE WHEN bi.status='${BuildingInspectionStatus.PASS}' THEN 1 ELSE NULL END) AS pass`)
+      .addSelect(`COUNT(CASE WHEN bi.status='${BuildingInspectionStatus.FAIL}' THEN 1 ELSE NULL END) AS fail`)
+      .where('bi.building_level_id = :buildingLevelId', { buildingLevelId })
+      .groupBy('bi.building_level_id')
+      .getRawOne()
+
+    return {
+      wait: buildingInspectionSummary?.wait || 0,
+      request: buildingInspectionSummary?.request || 0,
+      pass: buildingInspectionSummary?.pass || 0,
+      fail: buildingInspectionSummary?.fail || 0
+    }
+  }
+
+  // 층 별로 검수 개수 써머리
+  @FieldResolver(type => BuildingInspectionSummary)
+  async buildingInspectionSummary(@Root() buildingLevel: BuildingLevel): Promise<BuildingInspectionSummary> {
+    const buildingInspectionSummary = await getRepository(BuildingInspection)
+      .createQueryBuilder('bi')
+      .select(`COUNT(CASE WHEN bi.status='${BuildingInspectionStatus.WAIT}' THEN 1 ELSE NULL END) AS wait`)
+      .addSelect(`COUNT(CASE WHEN bi.status='${BuildingInspectionStatus.REQUEST}' THEN 1 ELSE NULL END) AS request`)
+      .addSelect(`COUNT(CASE WHEN bi.status='${BuildingInspectionStatus.PASS}' THEN 1 ELSE NULL END) AS pass`)
+      .addSelect(`COUNT(CASE WHEN bi.status='${BuildingInspectionStatus.FAIL}' THEN 1 ELSE NULL END) AS fail`)
+      .where('bi.building_level_id = :buildingLevelId', { buildingLevelId: buildingLevel.id })
+      .groupBy('bi.building_level_id')
+      .getRawOne()
+
+    return {
+      wait: buildingInspectionSummary?.wait || 0,
+      request: buildingInspectionSummary?.request || 0,
+      pass: buildingInspectionSummary?.pass || 0,
+      fail: buildingInspectionSummary?.fail || 0
+    }
+  }
+
+  @Query(returns => BuildingInspectionSummary, { description: '프로젝트의 검측상태 별 카운트' })
+  async buildingInspectionSummaryOfProject(
+    @Arg('projectId') projectId: string,
+    @Ctx() context: ResolverContext
+  ): Promise<BuildingInspectionSummary> {
+    const { domain } = context.state
+
+    const result = await getRepository(Project)
+      .createQueryBuilder('p')
+      .select(`COUNT(CASE WHEN bi.status = '${BuildingInspectionStatus.WAIT}' THEN 1 ELSE NULL END) AS wait`)
+      .addSelect(`COUNT(CASE WHEN bi.status = '${BuildingInspectionStatus.REQUEST}' THEN 1 ELSE NULL END) AS request`)
+      .addSelect(`COUNT(CASE WHEN bi.status = '${BuildingInspectionStatus.PASS}' THEN 1 ELSE NULL END) AS pass`)
+      .addSelect(`COUNT(CASE WHEN bi.status = '${BuildingInspectionStatus.FAIL}' THEN 1 ELSE NULL END) AS fail`)
+      .innerJoin('p.buildingComplex', 'bc')
+      .innerJoin('bc.buildings', 'b')
+      .innerJoin('b.buildingLevels', 'bl')
+      .leftJoin('building_inspections', 'bi', 'bi.building_level_id = bl.id AND bi.deleted_at IS NULL')
+      .where('p.domain = :domain', { domain: domain.id })
+      .andWhere('p.id = :projectId', { projectId })
+      .groupBy('p.id')
+      .getRawOne()
+
+    return {
+      wait: result.wait || 0,
+      request: result.request || 0,
+      pass: result.pass || 0,
+      fail: result.fail || 0
+    }
+  }
+
+  @FieldResolver(type => Checklist)
+  async checklist(@Root() buildingInspection: BuildingInspection): Promise<Checklist> {
+    return await getRepository(Checklist).findOneBy({ id: buildingInspection.checklistId })
+  }
+
+  @FieldResolver(type => BuildingLevel)
+  async buildingLevel(@Root() buildingInspection: BuildingInspection): Promise<BuildingLevel> {
+    return await getRepository(BuildingLevel).findOneBy({ id: buildingInspection.buildingLevelId })
+  }
+
+  @FieldResolver(type => [Attachment])
+  async attatchments(@Root() buildingInspection: BuildingInspection): Promise<Attachment[] | undefined> {
+    const attachment: Attachment[] = await getRepository(Attachment).find({
+      where: {
+        refType: BuildingInspection.name,
+        refBy: buildingInspection.id
+      }
+    })
+    return attachment
+  }
+}

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

@@ -0,0 +1,101 @@
+import { ObjectType, Field, InputType, Int, ID } from 'type-graphql'
+import { BuildingInspection } from './building-inspection'
+
+@InputType()
+class ChecklistInputType {
+  @Field({ nullable: false })
+  name: string
+
+  @Field({ nullable: false })
+  constructionType: string
+
+  @Field({ nullable: false })
+  constructionDetailType: string
+
+  @Field({ nullable: false })
+  location?: string
+
+  @Field({ nullable: false })
+  inspectionDrawingType?: string
+
+  @Field(type => [String], { nullable: false })
+  inspectionParts?: string[]
+}
+
+@InputType()
+class ChecklistItemInputType {
+  @Field({ nullable: false })
+  name: string
+
+  @Field({ nullable: false })
+  mainType: string
+
+  @Field({ nullable: false })
+  detailType: string
+
+  @Field({ nullable: true })
+  inspctionCriteria: string
+}
+
+@InputType()
+export class NewBuildingInspection {
+  @Field({ nullable: false })
+  buildingLevelId: string
+
+  @Field(type => ChecklistInputType, { nullable: false })
+  checklist: ChecklistInputType
+
+  @Field(type => [ChecklistItemInputType], { nullable: false })
+  checklistItem: ChecklistItemInputType[]
+}
+
+@InputType()
+export class UpdateBuildingInspection {
+  @Field({ nullable: false })
+  id: string
+
+  @Field(type => String, { nullable: true })
+  drawingMarker?: string
+}
+
+@InputType()
+export class BuildingInspectionsOfProject {
+  @Field({ nullable: false })
+  projectId: string
+
+  @Field({ nullable: true })
+  limit: number
+}
+
+@InputType()
+export class BuildingInspectionsOfBuildingLevel {
+  @Field({ nullable: false })
+  buildingLevelId: string
+
+  @Field({ nullable: true })
+  limit: number
+}
+
+@ObjectType()
+export class BuildingInspectionSummary {
+  @Field(type => Int, { description: '검측 대기 수' })
+  wait: number
+
+  @Field(type => Int, { description: '검측 요청 수' })
+  request: number
+
+  @Field(type => Int, { description: '검측 통과 수' })
+  pass: number
+
+  @Field(type => Int, { description: '검측 실패 수' })
+  fail: number
+}
+
+@ObjectType()
+export class BuildingInspectionList {
+  @Field(type => [BuildingInspection])
+  items: BuildingInspection[]
+
+  @Field(type => Int)
+  total: number
+}

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

@@ -0,0 +1,106 @@
+import {
+  CreateDateColumn,
+  UpdateDateColumn,
+  DeleteDateColumn,
+  Entity,
+  Index,
+  Column,
+  RelationId,
+  ManyToOne,
+  OneToOne,
+  PrimaryGeneratedColumn,
+  JoinColumn
+} from 'typeorm'
+import { ObjectType, Field, ID, registerEnumType } from 'type-graphql'
+
+import { User } from '@things-factory/auth-base'
+import { BuildingLevel } from '@dssp/building-complex'
+import { Checklist } from '../checklist/checklist'
+
+export enum BuildingInspectionStatus {
+  WAIT = 'WAIT',
+  REQUEST = 'REQUEST',
+  PASS = 'PASS',
+  FAIL = 'FAIL'
+}
+
+registerEnumType(BuildingInspectionStatus, {
+  name: 'BuildingInspectionStatus',
+  description: '검측 상태'
+})
+
+@Entity({ comment: '시공 검측 (층별 도면의 검측 리스트)' })
+@Index('ix_building_inspection_0', (buildingInspection: BuildingInspection) => [buildingInspection.buildingLevel], {
+  where: '"deleted_at" IS NULL'
+})
+@Index('ix_building_inspection_1', (buildingInspection: BuildingInspection) => [buildingInspection.checklist], {
+  where: '"deleted_at" IS NULL'
+})
+@Index('ix_building_inspection_2', (buildingInspection: BuildingInspection) => [buildingInspection.requestDate], {
+  where: '"deleted_at" IS NULL'
+})
+@ObjectType()
+export class BuildingInspection {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @Column({
+    nullable: false,
+    comment: '상태(WAIT: 검측 대기, REQUEST: 검측 요청, PASS: 합격, FAIL: 불합격)',
+    default: 'WAIT'
+  })
+  @Field({ nullable: true })
+  status?: BuildingInspectionStatus
+
+  @Column({ nullable: false, comment: '검측 요청일' })
+  @Field({ nullable: true })
+  requestDate?: Date
+
+  @Column({ type: 'simple-json', nullable: true, comment: '도면 마커' })
+  @Field(type => String, { nullable: true })
+  drawingMarker?: string
+
+  // 층 정보 (1:1 상위 테이블 참조)
+  @ManyToOne(type => BuildingLevel)
+  @Field(() => BuildingLevel, { nullable: true })
+  buildingLevel?: BuildingLevel
+
+  @RelationId((buildingInspection: BuildingInspection) => buildingInspection.buildingLevel)
+  buildingLevelId?: string
+
+  // 체크리스트 (1:1 상위 테이블 참조)
+  @OneToOne(type => Checklist)
+  @JoinColumn()
+  @Field(() => Checklist, { nullable: true })
+  checklist?: Checklist
+
+  @RelationId((buildingInspection: BuildingInspection) => buildingInspection.checklist)
+  checklistId?: string
+
+  @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((buildingInspection: BuildingInspection) => buildingInspection.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId((buildingInspection: BuildingInspection) => buildingInspection.updater)
+  updaterId?: string
+}

package/server/service/building-inspection/event-subscriber.ts

@@ -0,0 +1,20 @@
+import { EventSubscriber } from 'typeorm'
+
+import { HistoryEntitySubscriber } from '@operato/typeorm-history'
+
+import { BuildingInspection } from './building-inspection'
+import { BuildingInspectionHistory } from './building-inspection-history'
+
+@EventSubscriber()
+export class BuildingInspectionHistoryEntitySubscriber extends HistoryEntitySubscriber<
+  BuildingInspection,
+  BuildingInspectionHistory
+> {
+  public get entity() {
+    return BuildingInspection
+  }
+
+  public get historyEntity() {
+    return BuildingInspectionHistory
+  }
+}

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

@@ -0,0 +1,11 @@
+import { BuildingInspection, BuildingInspectionStatus } from './building-inspection'
+import { BuildingInspectionQuery } from './building-inspection-query'
+import { BuildingInspectionMutation } from './building-inspection-mutation'
+import { BuildingInspectionSummary } from './building-inspection-type'
+import { BuildingInspectionHistory } from './building-inspection-history'
+import { BuildingInspectionHistoryEntitySubscriber } from './event-subscriber'
+
+export const entities = [BuildingInspection, BuildingInspectionHistory]
+export const resolvers = [BuildingInspectionQuery, BuildingInspectionMutation]
+export const subscribers = [BuildingInspectionHistoryEntitySubscriber]
+export const types = [BuildingInspectionStatus, BuildingInspectionSummary]

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

@@ -0,0 +1,96 @@
+import { Field, ID, ObjectType } from 'type-graphql'
+import { Column, Entity, Index, ManyToOne, PrimaryGeneratedColumn, RelationId } from 'typeorm'
+import { HistoryActionColumn, HistoryActionType, HistoryEntityInterface, HistoryOriginalIdColumn } from '@operato/typeorm-history'
+import { User } from '@things-factory/auth-base'
+import { config } from '@things-factory/env'
+import { Checklist } from './checklist'
+
+const ORMCONFIG = config.get('ormconfig', {})
+const DATABASE_TYPE = ORMCONFIG.type
+
+@Entity()
+@Index('ix_checklist_history_0', (checklistHistory: ChecklistHistory) => [checklistHistory.originalId])
+@ObjectType({ description: 'History Entity of Checklist' })
+export class ChecklistHistory implements HistoryEntityInterface<Checklist> {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @Column({ nullable: true, comment: '이름' })
+  @Field({ nullable: true })
+  name?: string
+
+  @Column({ nullable: true, comment: '문서 번호 동(4자리)-층(3자리)-시퀀스(6자리)' })
+  @Field({ nullable: true })
+  documentNo?: string
+
+  @Column({ nullable: false, comment: '공종' })
+  @Field({ nullable: true })
+  constructionType?: string
+
+  @Column({ nullable: false, comment: '세부 공종' })
+  @Field({ nullable: true })
+  constructionDetailType?: string
+
+  @Column({ nullable: false, comment: '위치 (x동 x층)' })
+  @Field({ nullable: true })
+  location?: string
+
+  @Column({ nullable: false, comment: '검측 도면 타입', default: '' })
+  @Field({ nullable: true })
+  inspectionDrawingType?: string
+
+  @Column('simple-array', { nullable: true, comment: '검측 부위' })
+  @Field(() => [String], { nullable: true })
+  inspectionParts?: string[]
+
+  @Column({ nullable: true, comment: '시공자 점검일' })
+  @Field({ nullable: true })
+  constructionInsprctionDate?: Date
+
+  @Column({ nullable: true, comment: '감리자 점검일' })
+  @Field({ nullable: true })
+  supervisorInsprctionDate?: Date
+
+  @Column({ nullable: true, comment: '총괄 시공 책임자 사인' })
+  @Field({ nullable: true })
+  overallConstructorSignature?: string
+
+  @Column({ nullable: true, comment: '공종별 시공 관리자 사인' })
+  @Field({ nullable: true })
+  taskConstructorSignature?: string
+
+  @Column({ nullable: true, comment: '총괄 감리 책임자 사인' })
+  @Field({ nullable: true })
+  overallSupervisorySignature?: string
+
+  @Column({ nullable: true, comment: '건축사보 (공종별 감리 관리자) 사인' })
+  @Field({ nullable: true })
+  taskSupervisorySignature?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  creator?: User
+
+  @RelationId((checklist: Checklist) => checklist.creator)
+  creatorId?: string
+
+  @HistoryOriginalIdColumn()
+  public originalId!: string
+
+  @HistoryActionColumn({
+    nullable: false,
+    type:
+      DATABASE_TYPE == 'postgres' || DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb'
+        ? 'enum'
+        : DATABASE_TYPE == 'oracle'
+          ? 'varchar2'
+          : 'smallint',
+    enum: HistoryActionType
+  })
+  public action!: HistoryActionType
+}

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

@@ -0,0 +1,103 @@
+import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
+import { In } from 'typeorm'
+import { Checklist } from './checklist'
+import { NewChecklist, ChecklistPatch } from './checklist-type'
+
+@Resolver(Checklist)
+export class ChecklistMutation {
+  @Directive('@transaction')
+  @Mutation(returns => Checklist, { description: 'To create new Checklist' })
+  async createChecklist(@Arg('checklist') checklist: NewChecklist, @Ctx() context: ResolverContext): Promise<Checklist> {
+    const { domain, user, tx } = context.state
+
+    const result = await tx.getRepository(Checklist).save({
+      ...checklist,
+      domain,
+      creator: user,
+      updater: user
+    })
+
+    return result
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Checklist, { description: 'To modify Checklist information' })
+  async updateChecklist(
+    @Arg('id') id: string,
+    @Arg('patch') patch: ChecklistPatch,
+    @Ctx() context: ResolverContext
+  ): Promise<Checklist> {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository(Checklist)
+    const checklist = await repository.findOne({
+      where: { id }
+    })
+
+    const result = await repository.save({
+      ...checklist,
+      ...patch,
+      updater: user
+    })
+
+    return result
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => [Checklist], { description: "To modify multiple Checklists' information" })
+  async updateMultipleChecklist(
+    @Arg('patches', type => [ChecklistPatch]) patches: ChecklistPatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<Checklist[]> {
+    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 checklistRepo = tx.getRepository(Checklist)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await checklistRepo.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 checklist = await checklistRepo.findOneBy({ id: updateRecord.id })
+
+        const result = await checklistRepo.save({
+          ...checklist,
+          ...updateRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple Checklists' })
+  async deleteChecklists(@Arg('ids', type => [String]) ids: string[], @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(Checklist).softDelete({
+      id: In(ids)
+    })
+
+    return true
+  }
+}

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

@@ -0,0 +1,52 @@
+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 { Checklist } from './checklist'
+import { ChecklistList } from './checklist-type'
+import { ChecklistItem } from '../checklist-item/checklist-item'
+
+@Resolver(Checklist)
+export class ChecklistQuery {
+  @Query(returns => Checklist!, { nullable: true, description: 'To fetch a Checklist' })
+  async checklist(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Checklist> {
+    const { domain } = context.state
+
+    return await getRepository(Checklist).findOne({
+      where: { id }
+    })
+  }
+
+  @Query(returns => ChecklistList, { description: 'To fetch multiple Checklists' })
+  async checklists(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<ChecklistList> {
+    const { domain } = context.state
+
+    const queryBuilder = getQueryBuilderFromListParams({
+      params,
+      repository: await getRepository(Checklist),
+      searchables: ['name', 'description']
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => [ChecklistItem])
+  async checklistItems(@Root() checklist: Checklist): Promise<ChecklistItem[]> {
+    return await getRepository(ChecklistItem)
+      .createQueryBuilder('ci')
+      .where('ci.checklist_id = :checklistId', { checklistId: checklist.id })
+      .orderBy('ci.sequence', 'ASC')
+      .getMany()
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() checklist: Checklist): Promise<User> {
+    return await getRepository(User).findOneBy({ id: checklist.updaterId })
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() checklist: Checklist): Promise<User> {
+    return await getRepository(User).findOneBy({ id: checklist.creatorId })
+  }
+}