@things-factory/accounting 7.0.6 → 7.1.2

package/server/service/accounting-document/accounting-document-type.ts

@@ -0,0 +1,52 @@
+import type { FileUpload } from 'graphql-upload/GraphQLUpload.js'
+import GraphQLUpload from 'graphql-upload/GraphQLUpload.js'
+import { ObjectType, Field, InputType, Int, ID, registerEnumType } from 'type-graphql'
+
+import { ObjectRef, ScalarObject } from '@things-factory/shell'
+
+import { AccountingDocument } from './accounting-document'
+
+@InputType()
+export class NewAccountingDocument {
+  @Field(type => ObjectRef)
+  transaction: ObjectRef
+
+  @Field({ nullable: false })
+  documentType: string // 문서의 유형 (예: 계약서, 인보이스 등)
+
+  @Field({ nullable: false })
+  documentUrl: string // 문서의 URL 또는 파일 경로
+
+  @Field({ nullable: true })
+  description?: string // 문서에 대한 설명
+}
+
+@InputType()
+export class AccountingDocumentPatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field(type => ObjectRef)
+  transaction: ObjectRef
+
+  @Field({ nullable: false })
+  documentType: string // 문서의 유형 (예: 계약서, 인보이스 등)
+
+  @Field({ nullable: false })
+  documentUrl: string // 문서의 URL 또는 파일 경로
+
+  @Field({ nullable: true })
+  description?: string // 문서에 대한 설명
+
+  @Field({ nullable: true })
+  cuFlag?: string
+}
+
+@ObjectType()
+export class AccountingDocumentList {
+  @Field(type => [AccountingDocument])
+  items: AccountingDocument[]
+
+  @Field(type => Int)
+  total: number
+}

package/server/service/accounting-document/accounting-document.ts

@@ -0,0 +1,93 @@
+import {
+  CreateDateColumn,
+  UpdateDateColumn,
+  DeleteDateColumn,
+  Entity,
+  Index,
+  Column,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+  RelationId,
+  VersionColumn
+} from 'typeorm'
+import { ObjectType, Field, ID } from 'type-graphql'
+
+import { Domain } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { Transaction } from '../transaction/transaction'
+
+@ObjectType({ description: 'Entity for AccountingDocument' })
+@Entity()
+@Index(
+  'ix_accounting_document_0',
+  (accountingDocument: AccountingDocument) => [
+    accountingDocument.domain,
+    accountingDocument.transaction,
+    accountingDocument.createdAt
+  ],
+  {
+    unique: false,
+    where: '"deleted_at" IS NULL'
+  }
+)
+export class AccountingDocument {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @VersionColumn()
+  @Field({ nullable: true })
+  version?: number = 1
+
+  @ManyToOne(type => Domain)
+  @Field({ nullable: true })
+  domain?: Domain
+
+  @RelationId((accountingDocument: AccountingDocument) => accountingDocument.domain)
+  domainId?: string
+
+  @ManyToOne(type => Transaction, transaction => transaction.documents)
+  @Field(type => Transaction)
+  transaction: Transaction
+
+  @RelationId((accountingDocument: AccountingDocument) => accountingDocument.transaction)
+  transactionId: string
+
+  @Column()
+  @Field({ nullable: false })
+  documentType: string // 문서의 유형 (예: 계약서, 인보이스 등)
+
+  @Column()
+  @Field({ nullable: false })
+  documentUrl: string // 문서의 URL 또는 파일 경로
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  description?: 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((accountingDocument: AccountingDocument) => accountingDocument.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId((accountingDocument: AccountingDocument) => accountingDocument.updater)
+  updaterId?: string
+}

package/server/service/accounting-document/event-subscriber.ts

@@ -0,0 +1,17 @@
+import { EventSubscriber } from 'typeorm'
+
+import { HistoryEntitySubscriber } from '@operato/typeorm-history'
+
+import { AccountingDocument } from './accounting-document'
+import { AccountingDocumentHistory } from './accounting-document-history'
+
+@EventSubscriber()
+export class AccountingDocumentHistoryEntitySubscriber extends HistoryEntitySubscriber<AccountingDocument, AccountingDocumentHistory> {
+  public get entity() {
+    return AccountingDocument
+  }
+
+  public get historyEntity() {
+    return AccountingDocumentHistory
+  }
+}

package/server/service/accounting-document/index.ts

@@ -0,0 +1,9 @@
+import { AccountingDocument } from './accounting-document'
+import { AccountingDocumentHistory } from './accounting-document-history'
+import { AccountingDocumentHistoryEntitySubscriber } from './event-subscriber'
+import { AccountingDocumentQuery } from './accounting-document-query'
+import { AccountingDocumentMutation } from './accounting-document-mutation'
+
+export const entities = [AccountingDocument, AccountingDocumentHistory]
+export const resolvers = [AccountingDocumentQuery, AccountingDocumentMutation]
+export const subscribers = [AccountingDocumentHistoryEntitySubscriber]

package/server/service/common-type.ts

@@ -0,0 +1,12 @@
+import { registerEnumType } from 'type-graphql'
+
+export enum FiscalStatus {
+  OPEN = 'OPEN',
+  CLOSED = 'CLOSED',
+  FINALIZED = 'FINALIZED'
+}
+
+registerEnumType(FiscalStatus, {
+  name: 'FiscalStatus',
+  description: 'The status of a fiscal period (OPEN, CLOSED, FINALIZED)'
+})

package/server/service/financial-statement/financial-statement-history.ts

@@ -1,5 +1,5 @@
 import { Field, ID, ObjectType } from 'type-graphql'
-import { Column, Entity, Index, ManyToOne, PrimaryGeneratedColumn, RelationId } from 'typeorm'
+import { Column, Entity, Index, ManyToOne, OneToMany, PrimaryGeneratedColumn, RelationId } from 'typeorm'
 
 import {
   HistoryActionColumn,
@@ -11,7 +11,8 @@ import { Role, User } from '@things-factory/auth-base'
 import { config } from '@things-factory/env'
 import { Domain } from '@things-factory/shell'
 
-import { FinancialStatement, FinancialStatementStatus } from './financial-statement'
+import { FinancialStatement } from './financial-statement'
+import { FinancialStatementLineItem } from './financial-statement-line-item'
 
 const ORMCONFIG = config.get('ormconfig', {})
 const DATABASE_TYPE = ORMCONFIG.type
@@ -45,31 +46,39 @@ export class FinancialStatementHistory implements HistoryEntityInterface<Financi
   version?: number = 1
 
   @ManyToOne(type => Domain)
-  @Field(type => Domain)
+  @Field({ nullable: true })
   domain?: Domain
 
-  @RelationId((financialStatement: FinancialStatement) => financialStatement.domain)
+  @RelationId((financialStatementHistory: FinancialStatementHistory) => financialStatementHistory.domain)
   domainId?: string
 
-  @Column()
-  @Field()
-  name: string
+  @Column({ nullable: true })
+  @Field({ nullable: true, description: 'Fiscal year of the financial statement' })
+  year?: number // 회계 연도
 
   @Column({ nullable: true })
-  @Field({ nullable: true })
-  description?: string
+  @Field({ nullable: true, description: 'Fiscal quarter of the financial statement' })
+  quarter?: number // 회계 분기
 
   @Column({ nullable: true })
-  @Field({ nullable: true })
-  active?: boolean
+  @Field({ nullable: true, description: 'Fiscal month of the financial statement' })
+  month?: number // 회계 월
 
   @Column({ nullable: true })
-  @Field({ nullable: true })
-  state?: FinancialStatementStatus
+  @Field({ nullable: true, description: 'Total assets recorded in the financial statement' })
+  asset?: number // 재무제표에 기록된 총자산
 
   @Column({ nullable: true })
-  @Field({ nullable: true })
-  params?: string
+  @Field({ nullable: true, description: 'Total liabilities recorded in the financial statement' })
+  liability?: number // 재무제표에 기록된 총부채
+
+  @Column({ nullable: true })
+  @Field({ nullable: true, description: 'Total equity recorded in the financial statement' })
+  equity?: number // 재무제표에 기록된 총자본
+
+  @OneToMany(type => FinancialStatementLineItem, lineItem => lineItem.statement)
+  @Field(type => [FinancialStatementLineItem], { nullable: true })
+  lineItems?: FinancialStatementLineItem[] // 계정별 브레이크다운
 
   @Column({ nullable: true })
   @Field({ nullable: true })
@@ -84,17 +93,17 @@ export class FinancialStatementHistory implements HistoryEntityInterface<Financi
   deletedAt?: Date
 
   @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
+  @Field({ nullable: true })
   creator?: User
 
-  @RelationId((financialStatement: FinancialStatement) => financialStatement.creator)
+  @RelationId((financialStatementHistory: FinancialStatementHistory) => financialStatementHistory.creator)
   creatorId?: string
 
   @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
+  @Field({ nullable: true })
   updater?: User
 
-  @RelationId((financialStatement: FinancialStatement) => financialStatement.updater)
+  @RelationId((financialStatementHistory: FinancialStatementHistory) => financialStatementHistory.updater)
   updaterId?: string
 
   @HistoryOriginalIdColumn()

package/server/service/financial-statement/financial-statement-line-item.ts

@@ -0,0 +1,82 @@
+import {
+  CreateDateColumn,
+  UpdateDateColumn,
+  DeleteDateColumn,
+  Entity,
+  Index,
+  Column,
+  RelationId,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+  VersionColumn
+} from 'typeorm'
+import { ObjectType, Field, ID } from 'type-graphql'
+
+import { Domain } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { Account } from '../account/account'
+import { FinancialStatement } from './financial-statement'
+
+@ObjectType({ description: 'Line item for a financial statement, representing the breakdown of financial accounts' })
+@Entity()
+@Index(
+  'ix_financial_statement_line_item_0',
+  (lineItem: FinancialStatementLineItem) => [lineItem.statement, lineItem.account],
+  {
+    unique: false,
+    where: '"deleted_at" IS NULL'
+  }
+)
+export class FinancialStatementLineItem {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string // 고유 식별자 (UUID)
+
+  @ManyToOne(type => FinancialStatement, statement => statement.lineItems)
+  @Field(type => FinancialStatement, { description: 'The financial statement this line item is associated with' })
+  statement: FinancialStatement // 연결된 재무제표
+
+  @RelationId((lineItem: FinancialStatementLineItem) => lineItem.statement)
+  statementId: string // 재무제표의 ID
+
+  @ManyToOne(type => Account)
+  @Field(type => Account, { description: 'The financial account associated with this line item' })
+  account: Account // 라인 아이템과 연결된 계정
+
+  @RelationId((lineItem: FinancialStatementLineItem) => lineItem.account)
+  accountId: string // 계정의 ID
+
+  @Column({ nullable: false })
+  @Field({ nullable: false, description: 'The monetary amount related to the financial account for this line item' })
+  amount: number // 계정에 대한 금액
+
+  @Column({ nullable: true })
+  @Field({ nullable: true, description: 'Optional description or notes for this line item' })
+  description?: string // 라인 아이템에 대한 선택적 설명 또는 메모
+
+  @CreateDateColumn()
+  @Field({ nullable: true, description: 'The date and time when this line item was created' })
+  createdAt?: Date // 라인 아이템이 생성된 날짜 및 시간
+
+  @UpdateDateColumn()
+  @Field({ nullable: true, description: 'The date and time when this line item was last updated' })
+  updatedAt?: Date // 라인 아이템이 마지막으로 업데이트된 날짜 및 시간
+
+  @DeleteDateColumn()
+  @Field({ nullable: true, description: 'The date and time when this line item was deleted' })
+  deletedAt?: Date // 라인 아이템이 삭제된 날짜 및 시간
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true, description: 'The user who created this line item' })
+  creator?: User // 라인 아이템을 생성한 사용자
+
+  @RelationId((lineItem: FinancialStatementLineItem) => lineItem.creator)
+  creatorId?: string // 생성자의 ID
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true, description: 'The user who last updated this line item' })
+  updater?: User // 라인 아이템을 마지막으로 업데이트한 사용자
+
+  @RelationId((lineItem: FinancialStatementLineItem) => lineItem.updater)
+  updaterId?: string // 업데이트한 사용자의 ID
+}

package/server/service/financial-statement/financial-statement-mutation.ts

@@ -1,7 +1,7 @@
 import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
 import { In } from 'typeorm'
 
-import { createAttachment, deleteAttachmentsByRef } from '@things-factory/attachment-base'
+import { getRepository } from '@things-factory/shell'
 
 import { FinancialStatement } from './financial-statement'
 import { NewFinancialStatement, FinancialStatementPatch } from './financial-statement-type'
@@ -9,6 +9,7 @@ import { NewFinancialStatement, FinancialStatementPatch } from './financial-stat
 @Resolver(FinancialStatement)
 export class FinancialStatementMutation {
   @Directive('@transaction')
+  @Directive('@privilege(category: "accounting", privilege: "mutation")')
   @Mutation(returns => FinancialStatement, { description: 'To create new FinancialStatement' })
   async createFinancialStatement(
     @Arg('financialStatement') financialStatement: NewFinancialStatement,
@@ -16,7 +17,7 @@ export class FinancialStatementMutation {
   ): Promise<FinancialStatement> {
     const { domain, user, tx } = context.state
 
-    const result = await tx.getRepository(FinancialStatement).save({
+    const result = await getRepository(FinancialStatement, tx).save({
       ...financialStatement,
       domain,
       creator: user,
@@ -27,6 +28,7 @@ export class FinancialStatementMutation {
   }
 
   @Directive('@transaction')
+  @Directive('@privilege(category: "accounting", privilege: "mutation")')
   @Mutation(returns => FinancialStatement, { description: 'To modify FinancialStatement information' })
   async updateFinancialStatement(
     @Arg('id') id: string,
@@ -35,7 +37,7 @@ export class FinancialStatementMutation {
   ): Promise<FinancialStatement> {
     const { domain, user, tx } = context.state
 
-    const repository = tx.getRepository(FinancialStatement)
+    const repository = getRepository(FinancialStatement, tx)
     const financialStatement = await repository.findOne({
       where: { domain: { id: domain.id }, id }
     })
@@ -50,6 +52,7 @@ export class FinancialStatementMutation {
   }
 
   @Directive('@transaction')
+  @Directive('@privilege(category: "accounting", privilege: "mutation")')
   @Mutation(returns => [FinancialStatement], { description: "To modify multiple FinancialStatements' information" })
   async updateMultipleFinancialStatement(
     @Arg('patches', type => [FinancialStatementPatch]) patches: FinancialStatementPatch[],
@@ -60,7 +63,7 @@ export class FinancialStatementMutation {
     let results = []
     const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
     const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
-    const financialStatementRepo = tx.getRepository(FinancialStatement)
+    const financialStatementRepo = getRepository(FinancialStatement, tx)
 
     if (_createRecords.length > 0) {
       for (let i = 0; i < _createRecords.length; i++) {
@@ -96,17 +99,18 @@ export class FinancialStatementMutation {
   }
 
   @Directive('@transaction')
+  @Directive('@privilege(category: "accounting", privilege: "mutation")')
   @Mutation(returns => Boolean, { description: 'To delete FinancialStatement' })
   async deleteFinancialStatement(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
     const { domain, tx } = context.state
 
-    await tx.getRepository(FinancialStatement).delete({ domain: { id: domain.id }, id })
-    await deleteAttachmentsByRef(null, { refBys: [id] }, context)
+    await getRepository(FinancialStatement, tx).delete({ domain: { id: domain.id }, id })
 
     return true
   }
 
   @Directive('@transaction')
+  @Directive('@privilege(category: "accounting", privilege: "mutation")')
   @Mutation(returns => Boolean, { description: 'To delete multiple FinancialStatements' })
   async deleteFinancialStatements(
     @Arg('ids', type => [String]) ids: string[],
@@ -114,17 +118,16 @@ export class FinancialStatementMutation {
   ): Promise<boolean> {
     const { domain, tx } = context.state
 
-    await tx.getRepository(FinancialStatement).delete({
+    await getRepository(FinancialStatement, tx).delete({
       domain: { id: domain.id },
       id: In(ids)
     })
 
-    await deleteAttachmentsByRef(null, { refBys: ids }, context)
-
     return true
   }
 
   @Directive('@transaction')
+  @Directive('@privilege(category: "accounting", privilege: "mutation")')
   @Mutation(returns => Boolean, { description: 'To import multiple FinancialStatements' })
   async importFinancialStatements(
     @Arg('financialStatements', type => [FinancialStatementPatch]) financialStatements: FinancialStatementPatch[],

package/server/service/financial-statement/financial-statement-query.ts

@@ -6,6 +6,7 @@ import { FinancialStatementList } from './financial-statement-type'
 
 @Resolver(FinancialStatement)
 export class FinancialStatementQuery {
+  @Directive('@privilege(category: "accounting", privilege: "query")')
   @Query(returns => FinancialStatement!, { nullable: true, description: 'To fetch a FinancialStatement' })
   async financialStatement(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<FinancialStatement> {
     const { domain } = context.state
@@ -15,9 +16,10 @@ export class FinancialStatementQuery {
     })
   }
 
+  @Directive('@privilege(category: "accounting", privilege: "query")')
   @Query(returns => FinancialStatementList, { description: 'To fetch multiple FinancialStatements' })
   async financialStatements(
-    @Args(type => ListParam) params: ListParam,
+    @Args() params: ListParam,
     @Ctx() context: ResolverContext
   ): Promise<FinancialStatementList> {
     const { domain } = context.state

package/server/service/financial-statement/financial-statement.ts

@@ -7,14 +7,17 @@ import {
   Column,
   RelationId,
   ManyToOne,
+  OneToMany,
   PrimaryGeneratedColumn,
   VersionColumn
 } from 'typeorm'
-import { ObjectType, Field, Int, ID, registerEnumType } from 'type-graphql'
+import { ObjectType, Field, ID, registerEnumType } from 'type-graphql'
 
 import { Domain } from '@things-factory/shell'
 import { User } from '@things-factory/auth-base'
 
+import { FinancialStatementLineItem } from './financial-statement-line-item'
+
 export enum FinancialStatementStatus {
   STATUS_A = 'STATUS_A',
   STATUS_B = 'STATUS_B'
@@ -22,79 +25,92 @@ export enum FinancialStatementStatus {
 
 registerEnumType(FinancialStatementStatus, {
   name: 'FinancialStatementStatus',
-  description: 'state enumeration of a financialStatement'
+  description: 'State enumeration of a financial statement' // 재무제표 상태 열거형
 })
 
+// 재무제표 (Financial Statement)
 @Entity()
 @Index(
   'ix_financial_statement_0',
-  (financialStatement: FinancialStatement) => [financialStatement.domain, financialStatement.deletedAt],
-  { unique: true }
+  (financialStatement: FinancialStatement) => [
+    financialStatement.domain,
+    financialStatement.year,
+    financialStatement.quarter,
+    financialStatement.month
+  ],
+  {
+    unique: true,
+    where: '"deleted_at" IS NULL' // 삭제되지 않은 경우에만 유니크
+  }
 )
-@ObjectType({ description: 'Entity for FinancialStatement' })
+@ObjectType({ description: 'Entity for FinancialStatement, representing the financial position of an entity' }) // 엔티티 설명 추가
 export class FinancialStatement {
   @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id: string
+  @Field(type => ID, { description: 'Unique identifier for the financial statement' })
+  readonly id: string // 고유 식별자 (UUID)
 
   @VersionColumn()
-  @Field({ nullable: true })
-  version?: number = 1
+  @Field({ nullable: true, description: 'Version number for optimistic locking' })
+  version?: number = 1 // 낙관적 잠금을 위한 버전 관리 필드
 
   @ManyToOne(type => Domain)
-  @Field(type => Domain)
-  domain?: Domain
+  @Field({ nullable: true, description: 'The domain to which this financial statement belongs' })
+  domain?: Domain // 이 재무제표가 속한 도메인
 
   @RelationId((financialStatement: FinancialStatement) => financialStatement.domain)
-  domainId?: string
+  domainId?: string // 도메인의 ID
 
   @Column({ nullable: true })
-  @Field({ nullable: true, description: 'fiscal year' })
-  year?: number
+  @Field({ nullable: true, description: 'Fiscal year of the financial statement' })
+  year?: number // 회계 연도
 
   @Column({ nullable: true })
-  @Field({ nullable: true, description: 'fiscal quarter' })
-  quarter?: number
+  @Field({ nullable: true, description: 'Fiscal quarter of the financial statement' })
+  quarter?: number // 회계 분기
 
   @Column({ nullable: true })
-  @Field({ nullable: true })
-  month?: number
+  @Field({ nullable: true, description: 'Fiscal month of the financial statement' })
+  month?: number // 회계 월
 
   @Column({ nullable: true })
-  @Field({ nullable: true })
-  asset?: number
+  @Field({ nullable: true, description: 'Total assets recorded in the financial statement' })
+  asset?: number // 재무제표에 기록된 총자산
 
   @Column({ nullable: true })
-  @Field({ nullable: true })
-  liability?: number
+  @Field({ nullable: true, description: 'Total liabilities recorded in the financial statement' })
+  liability?: number // 재무제표에 기록된 총부채
 
   @Column({ nullable: true })
-  @Field({ nullable: true })
-  equity?: number
+  @Field({ nullable: true, description: 'Total equity recorded in the financial statement' })
+  equity?: number // 재무제표에 기록된 총자본
+
+  @OneToMany(type => FinancialStatementLineItem, lineItem => lineItem.statement)
+  @Field(type => [FinancialStatementLineItem], { nullable: true })
+  lineItems?: FinancialStatementLineItem[] // 계정별 브레이크다운
 
   @CreateDateColumn()
-  @Field({ nullable: true })
-  createdAt?: Date
+  @Field({ nullable: true, description: 'The date and time when the financial statement was created' })
+  createdAt?: Date // 재무제표가 생성된 날짜 및 시간
 
   @UpdateDateColumn()
-  @Field({ nullable: true })
-  updatedAt?: Date
+  @Field({ nullable: true, description: 'The date and time when the financial statement was last updated' })
+  updatedAt?: Date // 재무제표가 마지막으로 업데이트된 날짜 및 시간
 
   @DeleteDateColumn()
-  @Field({ nullable: true })
-  deletedAt?: Date
+  @Field({ nullable: true, description: 'The date and time when the financial statement was deleted' })
+  deletedAt?: Date // 재무제표가 삭제된 날짜 및 시간
 
   @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  creator?: User
+  @Field(type => User, { nullable: true, description: 'The user who created the financial statement' })
+  creator?: User // 재무제표를 생성한 사용자
 
   @RelationId((financialStatement: FinancialStatement) => financialStatement.creator)
-  creatorId?: string
+  creatorId?: string // 재무제표를 생성한 사용자의 ID
 
   @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  updater?: User
+  @Field(type => User, { nullable: true, description: 'The user who last updated the financial statement' })
+  updater?: User // 재무제표를 마지막으로 업데이트한 사용자
 
   @RelationId((financialStatement: FinancialStatement) => financialStatement.updater)
-  updaterId?: string
+  updaterId?: string // 재무제표를 업데이트한 사용자의 ID
 }

package/server/service/financial-statement/index.ts

@@ -1,9 +1,10 @@
 import { FinancialStatement } from './financial-statement'
+import { FinancialStatementLineItem } from './financial-statement-line-item'
 import { FinancialStatementHistory } from './financial-statement-history'
 import { FinancialStatementQuery } from './financial-statement-query'
 import { FinancialStatementMutation } from './financial-statement-mutation'
 import { FinancialStatementHistoryEntitySubscriber } from './event-subscriber'
 
-export const entities = [FinancialStatement, FinancialStatementHistory]
+export const entities = [FinancialStatement, FinancialStatementLineItem, FinancialStatementHistory]
 export const resolvers = [FinancialStatementQuery, FinancialStatementMutation]
 export const subscribers = [FinancialStatementHistoryEntitySubscriber]