@things-factory/accounting 8.0.0-alpha.1 → 8.0.0-alpha.12

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

@@ -0,0 +1,84 @@
+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 { IncomeStatement } from './income-statement'
+
+@ObjectType({
+  description: 'Line item for an income statement, representing a detailed breakdown of financial accounts'
+})
+@Entity()
+@Index(
+  'ix_income_statement_line_item_0',
+  (lineItem: IncomeStatementLineItem) => [lineItem.statement, lineItem.account],
+  {
+    unique: false,
+    where: '"deleted_at" IS NULL'
+  }
+)
+export class IncomeStatementLineItem {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => IncomeStatement, statement => statement.lineItems)
+  @Field(type => IncomeStatement, { description: 'The income statement this line item belongs to' })
+  statement: IncomeStatement // 해당 라인 아이템이 속한 손익계산서
+
+  @RelationId((lineItem: IncomeStatementLineItem) => lineItem.statement)
+  statementId: string // 손익계산서의 ID
+
+  @ManyToOne(type => Account)
+  @Field(type => Account, { description: 'The financial account associated with this line item' })
+  account: Account // 라인 아이템에 연결된 계정
+
+  @RelationId((lineItem: IncomeStatementLineItem) => lineItem.account)
+  accountId: string // 계정의 ID
+
+  @Column({ nullable: false })
+  @Field({ nullable: false, description: 'The monetary amount associated with this account for the income statement' })
+  amount: number // 계정과 관련된 금액
+
+  @Column({ nullable: true })
+  @Field({ nullable: true, description: 'Optional description or notes about 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: IncomeStatementLineItem) => 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: IncomeStatementLineItem) => lineItem.updater)
+  updaterId?: string // 업데이트한 사용자의 ID
+}

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

@@ -1,7 +1,6 @@
 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 { IncomeStatement } from './income-statement'
 import { NewIncomeStatement, IncomeStatementPatch } from './income-statement-type'
@@ -9,6 +8,7 @@ import { NewIncomeStatement, IncomeStatementPatch } from './income-statement-typ
 @Resolver(IncomeStatement)
 export class IncomeStatementMutation {
   @Directive('@transaction')
+  @Directive('@privilege(category: "accounting", privilege: "mutation")')
   @Mutation(returns => IncomeStatement, { description: 'To create new IncomeStatement' })
   async createIncomeStatement(
     @Arg('incomeStatement') incomeStatement: NewIncomeStatement,
@@ -16,7 +16,7 @@ export class IncomeStatementMutation {
   ): Promise<IncomeStatement> {
     const { domain, user, tx } = context.state
 
-    const result = await tx.getRepository(IncomeStatement).save({
+    const result = await getRepository(IncomeStatement, tx).save({
       ...incomeStatement,
       domain,
       creator: user,
@@ -27,6 +27,7 @@ export class IncomeStatementMutation {
   }
 
   @Directive('@transaction')
+  @Directive('@privilege(category: "accounting", privilege: "mutation")')
   @Mutation(returns => IncomeStatement, { description: 'To modify IncomeStatement information' })
   async updateIncomeStatement(
     @Arg('id') id: string,
@@ -35,7 +36,7 @@ export class IncomeStatementMutation {
   ): Promise<IncomeStatement> {
     const { domain, user, tx } = context.state
 
-    const repository = tx.getRepository(IncomeStatement)
+    const repository = getRepository(IncomeStatement, tx)
     const incomeStatement = await repository.findOne({
       where: { domain: { id: domain.id }, id }
     })
@@ -50,6 +51,7 @@ export class IncomeStatementMutation {
   }
 
   @Directive('@transaction')
+  @Directive('@privilege(category: "accounting", privilege: "mutation")')
   @Mutation(returns => [IncomeStatement], { description: "To modify multiple IncomeStatements' information" })
   async updateMultipleIncomeStatement(
     @Arg('patches', type => [IncomeStatementPatch]) patches: IncomeStatementPatch[],
@@ -60,7 +62,7 @@ export class IncomeStatementMutation {
     let results = []
     const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
     const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
-    const incomeStatementRepo = tx.getRepository(IncomeStatement)
+    const incomeStatementRepo = getRepository(IncomeStatement, tx)
 
     if (_createRecords.length > 0) {
       for (let i = 0; i < _createRecords.length; i++) {
@@ -96,17 +98,18 @@ export class IncomeStatementMutation {
   }
 
   @Directive('@transaction')
+  @Directive('@privilege(category: "accounting", privilege: "mutation")')
   @Mutation(returns => Boolean, { description: 'To delete IncomeStatement' })
   async deleteIncomeStatement(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
     const { domain, tx } = context.state
 
-    await tx.getRepository(IncomeStatement).delete({ domain: { id: domain.id }, id })
-    await deleteAttachmentsByRef(null, { refBys: [id] }, context)
+    await getRepository(IncomeStatement, tx).delete({ domain: { id: domain.id }, id })
 
     return true
   }
 
   @Directive('@transaction')
+  @Directive('@privilege(category: "accounting", privilege: "mutation")')
   @Mutation(returns => Boolean, { description: 'To delete multiple IncomeStatements' })
   async deleteIncomeStatements(
     @Arg('ids', type => [String]) ids: string[],
@@ -114,17 +117,16 @@ export class IncomeStatementMutation {
   ): Promise<boolean> {
     const { domain, tx } = context.state
 
-    await tx.getRepository(IncomeStatement).delete({
+    await getRepository(IncomeStatement, 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 IncomeStatements' })
   async importIncomeStatements(
     @Arg('incomeStatements', type => [IncomeStatementPatch]) incomeStatements: IncomeStatementPatch[],

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

@@ -6,6 +6,7 @@ import { IncomeStatementList } from './income-statement-type'
 
 @Resolver(IncomeStatement)
 export class IncomeStatementQuery {
+  @Directive('@privilege(category: "accounting", privilege: "query")')
   @Query(returns => IncomeStatement!, { nullable: true, description: 'To fetch a IncomeStatement' })
   async incomeStatement(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<IncomeStatement> {
     const { domain } = context.state
@@ -15,6 +16,7 @@ export class IncomeStatementQuery {
     })
   }
 
+  @Directive('@privilege(category: "accounting", privilege: "query")')
   @Query(returns => IncomeStatementList, { description: 'To fetch multiple IncomeStatements' })
   async incomeStatements(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<IncomeStatementList> {
     const { domain } = context.state

package/server/service/income-statement/income-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 { IncomeStatementLineItem } from './income-statement-line-item'
+
 export enum IncomeStatementStatus {
   STATUS_A = 'STATUS_A',
   STATUS_B = 'STATUS_B'
@@ -22,84 +25,96 @@ export enum IncomeStatementStatus {
 
 registerEnumType(IncomeStatementStatus, {
   name: 'IncomeStatementStatus',
-  description: 'state enumeration of a incomeStatement'
+  description: 'State enumeration of an income statement' // 손익계산서의 상태 열거형
 })
 
-// 손익계산서
+// 손익계산서 (Income Statement)
 @Entity()
 @Index(
   'ix_income_statement_0',
-  (incomeStatement: IncomeStatement) => [incomeStatement.domain, incomeStatement.deletedAt],
-  { unique: false, where: '"deleted_at" IS NULL' }
+  (incomeStatement: IncomeStatement) => [
+    incomeStatement.domain,
+    incomeStatement.year,
+    incomeStatement.quarter,
+    incomeStatement.month
+  ],
+  {
+    unique: true,
+    where: '"deleted_at" IS NULL' // 삭제되지 않은 경우에만 유니크
+  }
 )
-@ObjectType({ description: 'Entity for IncomeStatement' })
+@ObjectType({ description: 'Entity for IncomeStatement, representing the profit and loss report' }) // 손익계산서 엔티티
 export class IncomeStatement {
   @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id: string
+  @Field(type => ID, { description: 'Unique identifier for the income 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({ nullable: true })
-  domain?: Domain
+  @Field({ nullable: true, description: 'The domain to which this income statement belongs' })
+  domain?: Domain // 이 손익계산서가 속한 도메인
 
   @RelationId((incomeStatement: IncomeStatement) => incomeStatement.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 income statement' })
+  year?: number // 회계 연도
 
   @Column({ nullable: true })
-  @Field({ nullable: true, description: 'fiscal quarter' })
-  quarter?: number
+  @Field({ nullable: true, description: 'Fiscal quarter of the income statement' })
+  quarter?: number // 회계 분기
 
   @Column({ nullable: true })
-  @Field({ nullable: true, description: 'fiscal month' })
-  month?: number
+  @Field({ nullable: true, description: 'Fiscal month of the income statement' })
+  month?: number // 회계 월
 
   @Column({ nullable: true })
-  @Field({ nullable: true })
-  revenue?: number
+  @Field({ nullable: true, description: 'Total revenue recorded in the income statement' })
+  revenue?: number // 손익계산서에 기록된 총수익
 
   @Column({ nullable: true })
-  @Field({ nullable: true })
-  expense?: number
+  @Field({ nullable: true, description: 'Total expenses recorded in the income statement' })
+  expense?: number // 손익계산서에 기록된 총비용
 
   @Column({ nullable: true })
-  @Field({ nullable: true })
-  netIncome?: number
+  @Field({ nullable: true, description: 'Net income calculated as revenue minus expenses' })
+  netIncome?: number // 총수익에서 총비용을 뺀 순이익
 
   @Column({ nullable: true })
-  @Field({ nullable: true })
-  active?: boolean
+  @Field({ nullable: true, description: 'Indicates whether this income statement is active' })
+  active?: boolean // 이 손익계산서가 활성 상태인지 여부
+
+  @OneToMany(type => IncomeStatementLineItem, lineItem => lineItem.statement)
+  @Field(type => [IncomeStatementLineItem], { nullable: true })
+  lineItems?: IncomeStatementLineItem[] // 계정별 브레이크다운
 
   @CreateDateColumn()
-  @Field({ nullable: true })
-  createdAt?: Date
+  @Field({ nullable: true, description: 'The date and time when the income statement was created' })
+  createdAt?: Date // 손익계산서가 생성된 날짜 및 시간
 
   @UpdateDateColumn()
-  @Field({ nullable: true })
-  updatedAt?: Date
+  @Field({ nullable: true, description: 'The date and time when the income statement was last updated' })
+  updatedAt?: Date // 손익계산서가 마지막으로 업데이트된 날짜 및 시간
 
   @DeleteDateColumn()
-  @Field({ nullable: true })
-  deletedAt?: Date
+  @Field({ nullable: true, description: 'The date and time when the income 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 income statement' })
+  creator?: User // 손익계산서를 생성한 사용자
 
   @RelationId((incomeStatement: IncomeStatement) => incomeStatement.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 income statement' })
+  updater?: User // 손익계산서를 마지막으로 업데이트한 사용자
 
   @RelationId((incomeStatement: IncomeStatement) => incomeStatement.updater)
-  updaterId?: string
+  updaterId?: string // 손익계산서를 업데이트한 사용자의 ID
 }

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

@@ -1,9 +1,10 @@
 import { IncomeStatement } from './income-statement'
+import { IncomeStatementLineItem } from './income-statement-line-item'
 import { IncomeStatementHistory } from './income-statement-history'
 import { IncomeStatementQuery } from './income-statement-query'
 import { IncomeStatementMutation } from './income-statement-mutation'
 import { IncomeStatementHistoryEntitySubscriber } from './event-subscriber'
 
-export const entities = [IncomeStatement, IncomeStatementHistory]
+export const entities = [IncomeStatement, IncomeStatementLineItem, IncomeStatementHistory]
 export const resolvers = [IncomeStatementQuery, IncomeStatementMutation]
 export const subscribers = [IncomeStatementHistoryEntitySubscriber]

package/server/service/index.ts

@@ -3,7 +3,9 @@ export * from './income-statement/income-statement'
 export * from './financial-statement/financial-statement'
 export * from './accounting-category/accounting-category'
 export * from './transaction/transaction'
+export * from './payment/payment'
 export * from './account/account'
+export * from './accounting-document/accounting-document'
 export * from './fiscal-month/fiscal-month'
 export * from './fiscal-quarter/fiscal-quarter'
 export * from './fiscal-year/fiscal-year'
@@ -29,11 +31,21 @@ import {
   resolvers as TransactionResolvers,
   subscribers as TransactionSubscribers
 } from './transaction'
+import {
+  entities as PaymentEntities,
+  resolvers as PaymentResolvers,
+  subscribers as PaymentSubscribers
+} from './payment'
 import {
   entities as AccountEntities,
   resolvers as AccountResolvers,
   subscribers as AccountSubscribers
 } from './account'
+import {
+  entities as AccountingDocumentEntities,
+  resolvers as AccountingDocumentResolvers,
+  subscribers as AccountingDocumentSubscribers
+} from './accounting-document'
 import {
   entities as FiscalMonthEntities,
   resolvers as FiscalMonthResolvers,
@@ -57,6 +69,8 @@ export const entities = [
   ...AccountingCategoryEntities,
   ...TransactionEntities,
   ...AccountEntities,
+  ...AccountingDocumentEntities,
+  ...PaymentEntities,
   ...FiscalMonthEntities,
   ...FiscalQuarterEntities,
   ...FiscalYearEntities
@@ -68,7 +82,9 @@ export const subscribers = [
   ...FinancialStatementSubscribers,
   ...AccountingCategorySubscribers,
   ...TransactionSubscribers,
+  ...PaymentSubscribers,
   ...AccountSubscribers,
+  ...AccountingDocumentSubscribers,
   ...FiscalYearSubscribers,
   ...FiscalMonthSubscribers,
   ...FiscalQuarterSubscribers,
@@ -82,7 +98,9 @@ export const schema = {
     ...FinancialStatementResolvers,
     ...AccountingCategoryResolvers,
     ...TransactionResolvers,
+    ...PaymentResolvers,
     ...AccountResolvers,
+    ...AccountingDocumentResolvers,
     ...FiscalMonthResolvers,
     ...FiscalQuarterResolvers,
     ...FiscalYearResolvers

package/server/service/payment/event-subscriber.ts

@@ -0,0 +1,17 @@
+import { EventSubscriber } from 'typeorm'
+
+import { HistoryEntitySubscriber } from '@operato/typeorm-history'
+
+import { Payment } from './payment'
+import { PaymentHistory } from './payment-history'
+
+@EventSubscriber()
+export class PaymentHistoryEntitySubscriber extends HistoryEntitySubscriber<Payment, PaymentHistory> {
+  public get entity() {
+    return Payment
+  }
+
+  public get historyEntity() {
+    return PaymentHistory
+  }
+}

package/server/service/payment/index.ts

@@ -0,0 +1,9 @@
+import { Payment } from './payment'
+import { PaymentHistory } from './payment-history'
+import { PaymentHistoryEntitySubscriber } from './event-subscriber'
+import { PaymentQuery } from './payment-query'
+import { PaymentMutation } from './payment-mutation'
+
+export const entities = [Payment, PaymentHistory]
+export const resolvers = [PaymentQuery, PaymentMutation]
+export const subscribers = [PaymentHistoryEntitySubscriber]

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

@@ -0,0 +1,149 @@
+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 { Role, User } from '@things-factory/auth-base'
+import { config } from '@things-factory/env'
+import { Domain } from '@things-factory/shell'
+
+import { Transaction } from '../transaction/transaction'
+import { Payment, PaymentDirection, PaymentType } from './payment'
+import { BankAccount } from 'service/bank-account/bank-account'
+
+const ORMCONFIG = config.get('ormconfig', {})
+const DATABASE_TYPE = ORMCONFIG.type
+
+@Entity()
+@Index(
+  'ix_payment_history_0',
+  (paymentHistory: PaymentHistory) => [paymentHistory.originalId, paymentHistory.version],
+  { unique: true }
+)
+@Index(
+  'ix_payment_history_1',
+  (paymentHistory: PaymentHistory) => [paymentHistory.domain, paymentHistory.originalId, paymentHistory.version],
+  { unique: true }
+)
+@ObjectType({ description: 'History Entity of Payment' })
+export class PaymentHistory implements HistoryEntityInterface<Payment> {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @Column({ nullable: true, default: 1 })
+  @Field({ nullable: true })
+  version?: number = 1
+
+  @ManyToOne(type => Domain)
+  @Field({ nullable: true })
+  domain?: Domain
+
+  @RelationId((payment: Payment) => payment.domain)
+  domainId?: string
+
+  @ManyToOne(type => Transaction, transaction => transaction.payments)
+  @Field(type => Transaction, { description: 'The transaction associated with this payment' })
+  transaction: Transaction // 결제와 연결된 트랜잭션
+
+  @RelationId((payment: Payment) => payment.transaction)
+  transactionId: string // 연결된 트랜잭션의 ID
+
+  @Column({ nullable: true })
+  @Field({ nullable: true, description: 'The currency used in the payment' })
+  currency?: string // 결제에 사용된 통화
+
+  @Column({ nullable: false })
+  @Field({ nullable: false, description: 'The amount of money involved in the payment' })
+  amount: number // 결제된 금액
+
+  @Column({ type: 'enum', enum: PaymentType, nullable: false })
+  @Field(type => PaymentType, { description: 'Type of the payment' })
+  paymentType: PaymentType // 결제 유형
+
+  @ManyToOne(type => BankAccount, { nullable: true })
+  @Field(type => BankAccount, { nullable: true, description: 'Source bank account for the payment' })
+  sourceBankAccount?: BankAccount
+
+  @RelationId((payment: Payment) => payment.sourceBankAccount)
+  sourceBankAccountId?: string
+
+  @ManyToOne(type => BankAccount, { nullable: true })
+  @Field(type => BankAccount, { nullable: true, description: 'Destination bank account for the payment' })
+  destinationBankAccount?: BankAccount
+
+  @RelationId((payment: Payment) => payment.destinationBankAccount)
+  destinationBankAccountId?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true, description: 'Fiscal year in which the payment was made' })
+  year?: number // 결제가 발생한 회계 연도
+
+  @Column({ nullable: true })
+  @Field({ nullable: true, description: 'Fiscal quarter in which the payment was made' })
+  quarter?: number // 결제가 발생한 회계 분기
+
+  @Column({ nullable: true })
+  @Field({ nullable: true, description: 'Fiscal month in which the payment was made' })
+  month?: number // 결제가 발생한 회계 월
+
+  @Column({ nullable: false })
+  @Field({ nullable: false, description: 'The date and time when the payment was made' })
+  paidAt: Date // 결제가 이루어진 날짜 및 시간
+
+  @Column({ nullable: false })
+  @Field(type => PaymentDirection, { description: 'Direction of the payment (Incoming or Outgoing)' })
+  direction: PaymentDirection // 결제 방향 (수금 또는 지출)
+
+  @Column({ nullable: true })
+  @Field({ nullable: true, description: 'Additional notes or comments about the payment' })
+  note?: string // 결제에 대한 추가 설명 또는 메모
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  deletedAt?: Date
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  creator?: User
+
+  @RelationId((payment: Payment) => payment.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId((payment: Payment) => payment.updater)
+  updaterId?: string
+
+  @Field(type => String, { nullable: true })
+  thumbnail?: 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
+}