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

package/server/migrations/1725200507196-seed-fiscal-entities.ts

@@ -0,0 +1,106 @@
+import { MigrationInterface, QueryRunner } from 'typeorm'
+import { Domain, getRepository } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { FiscalYear } from '../service/fiscal-year/fiscal-year'
+import { FiscalQuarter } from '../service/fiscal-quarter/fiscal-quarter'
+import { FiscalMonth } from '../service/fiscal-month/fiscal-month'
+import { FiscalStatus } from '../service/common-type'
+
+export class SeedFiscalEntities1725200507196 implements MigrationInterface {
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    const domainRepository = getRepository(Domain)
+    const userRepository = getRepository(User)
+    const fiscalYearRepository = getRepository(FiscalYear)
+    const fiscalQuarterRepository = getRepository(FiscalQuarter)
+    const fiscalMonthRepository = getRepository(FiscalMonth)
+
+    const domain: Domain | null = await domainRepository.findOne({
+      where: { name: 'SYSTEM' }
+    })
+
+    if (!domain) {
+      throw new Error('SYSTEM domain not found')
+    }
+
+    const user = await userRepository.findOne({ where: { id: domain.owner } })
+
+    if (!user) {
+      throw new Error('Domain owner not found')
+    }
+
+    const currentYear = new Date().getFullYear()
+
+    try {
+      // Fiscal Year 생성
+      const fiscalYear = await fiscalYearRepository.save({
+        domain,
+        year: currentYear,
+        startDate: `${currentYear}-01-01`, // 문자열로 저장
+        endDate: `${currentYear}-12-31`, // 문자열로 저장
+        status: FiscalStatus.OPEN,
+        creator: user,
+        updater: user
+      })
+
+      // Fiscal Quarters 생성
+      for (let quarter = 1; quarter <= 4; quarter++) {
+        const startMonth = (quarter - 1) * 3 + 1
+        const endMonth = quarter * 3
+
+        const fiscalQuarter = await fiscalQuarterRepository.save({
+          domain,
+          year: currentYear,
+          quarter,
+          startDate: `${currentYear}-${String(startMonth).padStart(2, '0')}-01`, // 문자열로 저장
+          endDate: `${currentYear}-${String(endMonth).padStart(2, '0')}-31`, // 임시로 월의 마지막 날을 31일로 설정
+          status: FiscalStatus.OPEN,
+          creator: user,
+          updater: user
+        })
+
+        // Fiscal Months 생성
+        for (let month = startMonth; month <= endMonth; month++) {
+          const startDate = `${currentYear}-${String(month).padStart(2, '0')}-01`
+          const endDate = `${currentYear}-${String(month).padStart(2, '0')}-${new Date(currentYear, month, 0).getDate()}`
+
+          await fiscalMonthRepository.save({
+            domain,
+            year: currentYear,
+            quarter,
+            month,
+            startDate,
+            endDate,
+            status: FiscalStatus.OPEN,
+            creator: user,
+            updater: user
+          })
+        }
+      }
+    } catch (error) {
+      console.error('Failed to seed fiscal entities:', error)
+      throw error
+    }
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    const domainRepository = getRepository(Domain)
+    const fiscalYearRepository = getRepository(FiscalYear)
+    const fiscalQuarterRepository = getRepository(FiscalQuarter)
+    const fiscalMonthRepository = getRepository(FiscalMonth)
+
+    const domain: Domain | null = await domainRepository.findOne({
+      where: { name: 'SYSTEM' }
+    })
+
+    if (!domain) {
+      throw new Error('SYSTEM domain not found')
+    }
+
+    const currentYear = new Date().getFullYear()
+
+    // FiscalMonth, FiscalQuarter, FiscalYear 삭제
+    await fiscalMonthRepository.delete({ domain, year: currentYear })
+    await fiscalQuarterRepository.delete({ domain, year: currentYear })
+    await fiscalYearRepository.delete({ domain, year: currentYear })
+  }
+}

package/server/migrations/1725201467183-seed-accounts.ts

@@ -0,0 +1,339 @@
+import { MigrationInterface, QueryRunner } from 'typeorm'
+import { Domain, getRepository } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { Account } from '../service/account/account'
+import { AccountingCategory } from '../service/accounting-category/accounting-category'
+
+export class SeedAccounts1725201467183 implements MigrationInterface {
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    const domainRepository = getRepository(Domain)
+    const userRepository = getRepository(User)
+    const accountingCategoryRepository = getRepository(AccountingCategory)
+    const accountRepository = getRepository(Account)
+
+    const domain: Domain | null = await domainRepository.findOne({
+      where: { name: 'SYSTEM' }
+    })
+
+    if (!domain) {
+      throw new Error('SYSTEM domain not found')
+    }
+
+    const user = await userRepository.findOne({ where: { id: domain.owner } })
+
+    if (!user) {
+      throw new Error('Domain owner not found')
+    }
+
+    try {
+      // 최상위 카테고리 생성
+      const topLevelCategories = {
+        자산: await accountingCategoryRepository.save({
+          domain,
+          code: 'ASSET',
+          name: '자산',
+          description: '기업이 소유하고 있는 자산',
+          creator: user,
+          updater: user
+        }),
+        부채: await accountingCategoryRepository.save({
+          domain,
+          code: 'LIABILITY',
+          name: '부채',
+          description: '기업이 갚아야 할 빚',
+          creator: user,
+          updater: user
+        }),
+        자본: await accountingCategoryRepository.save({
+          domain,
+          code: 'EQUITY',
+          name: '자본',
+          description: '기업 소유주의 자산',
+          creator: user,
+          updater: user
+        }),
+        수익: await accountingCategoryRepository.save({
+          domain,
+          code: 'REVENUE',
+          name: '수익',
+          description: '기업이 벌어들인 돈',
+          creator: user,
+          updater: user
+        }),
+        비용: await accountingCategoryRepository.save({
+          domain,
+          code: 'EXPENSE',
+          name: '비용',
+          description: '기업 운영에 사용된 돈',
+          creator: user,
+          updater: user
+        })
+      }
+
+      // 유동자산 및 비유동자산과 같은 하위 카테고리 생성
+      const subCategories = {
+        유동자산: await accountingCategoryRepository.save({
+          domain,
+          code: 'CURRENT_ASSET',
+          name: '유동자산',
+          description: '쉽게 현금화할 수 있는 자산',
+          parent: topLevelCategories.자산,
+          creator: user,
+          updater: user
+        }),
+        비유동자산: await accountingCategoryRepository.save({
+          domain,
+          code: 'NON_CURRENT_ASSET',
+          name: '비유동자산',
+          description: '장기 보유 자산',
+          parent: topLevelCategories.자산,
+          creator: user,
+          updater: user
+        }),
+        유동부채: await accountingCategoryRepository.save({
+          domain,
+          code: 'CURRENT_LIABILITY',
+          name: '유동부채',
+          description: '단기간에 상환해야 하는 부채',
+          parent: topLevelCategories.부채,
+          creator: user,
+          updater: user
+        }),
+        비유동부채: await accountingCategoryRepository.save({
+          domain,
+          code: 'NON_CURRENT_LIABILITY',
+          name: '비유동부채',
+          description: '장기 부채',
+          parent: topLevelCategories.부채,
+          creator: user,
+          updater: user
+        })
+      }
+
+      // 이제 유형자산, 무형자산, 단기금융부채 같은 하위 카테고리를 subCategories 객체를 사용하여 생성합니다.
+      const furtherSubCategories = {
+        유형자산: await accountingCategoryRepository.save({
+          domain,
+          code: 'TANGIBLE_ASSET',
+          name: '유형자산',
+          description: '물리적 형태가 있는 자산',
+          parent: subCategories.비유동자산,
+          creator: user,
+          updater: user
+        }),
+        무형자산: await accountingCategoryRepository.save({
+          domain,
+          code: 'INTANGIBLE_ASSET',
+          name: '무형자산',
+          description: '물리적 형태가 없는 자산',
+          parent: subCategories.비유동자산,
+          creator: user,
+          updater: user
+        }),
+        단기금융부채: await accountingCategoryRepository.save({
+          domain,
+          code: 'SHORT_TERM_FINANCIAL_LIABILITY',
+          name: '단기금융부채',
+          description: '단기적으로 갚아야 할 금융부채',
+          parent: subCategories.유동부채,
+          creator: user,
+          updater: user
+        })
+      }
+
+      // 계정 생성 및 하위 카테고리 연결
+      const accounts = [
+        // 유동자산 계정
+        {
+          controlNumber: '101',
+          name: '현금 및 현금성 자산',
+          description: '현금, 예금 및 기타 현금성 자산',
+          category: subCategories.유동자산
+        },
+        {
+          controlNumber: '102',
+          name: '매출채권',
+          description: '상품 또는 서비스의 판매로 인해 발생한 채권',
+          category: subCategories.유동자산
+        },
+        {
+          controlNumber: '103',
+          name: '재고자산',
+          description: '판매를 목적으로 보유한 상품, 제품, 원재료 등',
+          category: subCategories.유동자산
+        },
+        {
+          controlNumber: '104',
+          name: '단기금융상품',
+          description: '단기투자 목적으로 보유한 금융상품',
+          category: subCategories.유동자산
+        },
+        {
+          controlNumber: '105',
+          name: '선급금',
+          description: '상품, 서비스 제공을 위해 미리 지급한 금액',
+          category: subCategories.유동자산
+        },
+
+        // 비유동자산 계정
+        {
+          controlNumber: '201',
+          name: '건물',
+          description: '기업이 소유한 건물',
+          category: furtherSubCategories.유형자산
+        },
+        {
+          controlNumber: '202',
+          name: '토지',
+          description: '기업이 소유한 토지',
+          category: furtherSubCategories.유형자산
+        },
+        {
+          controlNumber: '203',
+          name: '기계장치',
+          description: '생산을 위해 사용되는 기계 및 장치',
+          category: furtherSubCategories.유형자산
+        },
+        {
+          controlNumber: '204',
+          name: '무형자산',
+          description: '특허권, 상표권 등의 무형자산',
+          category: furtherSubCategories.무형자산
+        },
+
+        // 유동부채 계정
+        {
+          controlNumber: '301',
+          name: '매입채무',
+          description: '상품 또는 서비스의 구매로 인해 발생한 채무',
+          category: subCategories.유동부채
+        },
+        {
+          controlNumber: '302',
+          name: '단기차입금',
+          description: '단기 대출금',
+          category: furtherSubCategories.단기금융부채
+        },
+        {
+          controlNumber: '303',
+          name: '미지급금',
+          description: '이미 발생한 비용에 대한 지급할 금액',
+          category: subCategories.유동부채
+        },
+        {
+          controlNumber: '304',
+          name: '선수금',
+          description: '고객으로부터 미리 받은 금액',
+          category: subCategories.유동부채
+        },
+
+        // 비유동부채 계정
+        { controlNumber: '401', name: '장기차입금', description: '장기 대출금', category: subCategories.비유동부채 },
+        {
+          controlNumber: '402',
+          name: '퇴직급여충당부채',
+          description: '퇴직급여 지급을 위해 설정한 부채',
+          category: subCategories.비유동부채
+        },
+
+        // 자본 계정
+        { controlNumber: '501', name: '자본금', description: '주주가 납입한 자본', category: topLevelCategories.자본 },
+        { controlNumber: '502', name: '이익잉여금', description: '이익의 축적', category: topLevelCategories.자본 },
+
+        // 수익 계정
+        {
+          controlNumber: '601',
+          name: '제품매출',
+          description: '제품의 판매로 인한 수익',
+          category: topLevelCategories.수익
+        },
+        {
+          controlNumber: '602',
+          name: '상품매출',
+          description: '상품의 판매로 인한 수익',
+          category: topLevelCategories.수익
+        },
+        {
+          controlNumber: '603',
+          name: '용역매출',
+          description: '용역 제공으로 인한 수익',
+          category: topLevelCategories.수익
+        },
+        {
+          controlNumber: '604',
+          name: '이자수익',
+          description: '금융 자산에서 발생한 이자수익',
+          category: topLevelCategories.수익
+        },
+        {
+          controlNumber: '605',
+          name: '배당금수익',
+          description: '주식 투자로 인한 배당금 수익',
+          category: topLevelCategories.수익
+        },
+
+        // 비용 계정
+        {
+          controlNumber: '701',
+          name: '매출원가',
+          description: '제품, 상품, 용역 제공에 대한 원가',
+          category: topLevelCategories.비용
+        },
+        { controlNumber: '702', name: '급여', description: '직원 급여 비용', category: topLevelCategories.비용 },
+        { controlNumber: '703', name: '임대료', description: '건물 및 설비 임차료', category: topLevelCategories.비용 },
+        {
+          controlNumber: '704',
+          name: '감가상각비',
+          description: '유형자산의 감가상각비용',
+          category: topLevelCategories.비용
+        },
+        {
+          controlNumber: '705',
+          name: '이자비용',
+          description: '차입금에 대한 이자비용',
+          category: topLevelCategories.비용
+        },
+        {
+          controlNumber: '706',
+          name: '판매비 및 관리비',
+          description: '기업 운영에 필요한 비용',
+          category: topLevelCategories.비용
+        },
+        { controlNumber: '707', name: '법인세비용', description: '법인세 납부 비용', category: topLevelCategories.비용 }
+      ]
+
+      // 계정 저장
+      for (const account of accounts) {
+        await accountRepository.save({
+          domain,
+          ...account,
+          creator: user,
+          updater: user
+        })
+      }
+    } catch (error) {
+      console.error('Failed to seed accounting categories and accounts:', error)
+      throw error
+    }
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    const domainRepository = getRepository(Domain)
+    const accountingCategoryRepository = getRepository(AccountingCategory)
+    const accountRepository = getRepository(Account)
+
+    const domain: Domain | null = await domainRepository.findOne({
+      where: { name: 'SYSTEM' }
+    })
+
+    if (!domain) {
+      throw new Error('SYSTEM domain not found')
+    }
+
+    // Accounts 삭제
+    await accountRepository.delete({ domain })
+
+    // AccountingCategories 삭제
+    await accountingCategoryRepository.delete({ domain })
+  }
+}

package/server/routes.ts

@@ -1,3 +1,5 @@
+const debug = require('debug')('things-factory:accounting:routes')
+
 process.on('bootstrap-module-global-public-route' as any, (app, globalPublicRouter) => {
   /*
    * can add global public routes to application (auth not required, tenancy not required)

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

@@ -38,7 +38,7 @@ export class AccountHistory implements HistoryEntityInterface<Account> {
   version?: number = 1
 
   @ManyToOne(type => Domain)
-  @Field(type => Domain)
+  @Field({ nullable: true })
   domain?: Domain
 
   @RelationId((account: Account) => account.domain)
@@ -73,14 +73,14 @@ export class AccountHistory implements HistoryEntityInterface<Account> {
   deletedAt?: Date
 
   @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
+  @Field({ nullable: true })
   creator?: User
 
   @RelationId((account: Account) => account.creator)
   creatorId?: string
 
   @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
+  @Field({ nullable: true })
   updater?: User
 
   @RelationId((account: Account) => account.updater)
@@ -95,8 +95,8 @@ export class AccountHistory implements HistoryEntityInterface<Account> {
       DATABASE_TYPE == 'postgres' || DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb'
         ? 'enum'
         : DATABASE_TYPE == 'oracle'
-          ? 'varchar2'
-          : 'smallint',
+        ? 'varchar2'
+        : 'smallint',
     enum: HistoryActionType
   })
   public action!: HistoryActionType

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

@@ -17,7 +17,7 @@ export class AccountQuery {
   }
 
   @Query(returns => AccountList, { description: 'To fetch multiple Accounts' })
-  async accounts(@Args(type => ListParam) params: ListParam, @Ctx() context: ResolverContext): Promise<AccountList> {
+  async accounts(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<AccountList> {
     const { domain } = context.state
 
     const queryBuilder = getQueryBuilderFromListParams({

package/server/service/account/account.ts

@@ -29,7 +29,7 @@ export class Account {
   version?: number = 1
 
   @ManyToOne(type => Domain)
-  @Field(type => Domain)
+  @Field({ nullable: true })
   domain?: Domain
 
   @RelationId((account: Account) => account.domain)

package/server/service/accounting-category/accounting-category-query.ts

@@ -17,7 +17,7 @@ export class AccountingCategoryQuery {
 
   @Query(returns => AccountingCategoryList, { description: 'To fetch multiple AccountingCategories' })
   async accountingCategories(
-    @Args(type => ListParam) params: ListParam,
+    @Args() params: ListParam,
     @Ctx() context: ResolverContext
   ): Promise<AccountingCategoryList> {
     const { domain } = context.state

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

@@ -4,6 +4,9 @@ import { AccountingCategory } from './accounting-category'
 
 @InputType()
 export class NewAccountingCategory {
+  @Field({ nullable: true, description: 'Account category code' })
+  code: string
+
   @Field()
   name: string
 
@@ -19,6 +22,9 @@ export class AccountingCategoryPatch {
   @Field(type => ID, { nullable: true })
   id?: string
 
+  @Field({ nullable: true, description: 'Account category code' })
+  code?: string
+
   @Field({ nullable: true })
   name?: string
 

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

@@ -20,6 +20,11 @@ import { User } from '@things-factory/auth-base'
   (accountingCategory: AccountingCategory) => [accountingCategory.domain, accountingCategory.name],
   { unique: true }
 )
+@Index(
+  'ix_accounting_category_1',
+  (accountingCategory: AccountingCategory) => [accountingCategory.domain, accountingCategory.code],
+  { unique: true }
+)
 @ObjectType({ description: 'Entity for AccountingCategory' })
 export class AccountingCategory {
   @PrimaryGeneratedColumn('uuid')
@@ -27,12 +32,16 @@ export class AccountingCategory {
   readonly id: string
 
   @ManyToOne(type => Domain)
-  @Field(type => Domain)
+  @Field({ nullable: true })
   domain?: Domain
 
   @RelationId((accountingCategory: AccountingCategory) => accountingCategory.domain)
   domainId?: string
 
+  @Column()
+  @Field({ nullable: true, description: 'Account category code' })
+  code?: string
+
   @Column()
   @Field({ nullable: true })
   name?: string

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

@@ -45,7 +45,7 @@ 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)
@@ -84,14 +84,14 @@ 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)
   creatorId?: string
 
   @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
+  @Field({ nullable: true })
   updater?: User
 
   @RelationId((financialStatement: FinancialStatement) => financialStatement.updater)
@@ -106,8 +106,8 @@ export class FinancialStatementHistory implements HistoryEntityInterface<Financi
       DATABASE_TYPE == 'postgres' || DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb'
         ? 'enum'
         : DATABASE_TYPE == 'oracle'
-          ? 'varchar2'
-          : 'smallint',
+        ? 'varchar2'
+        : 'smallint',
     enum: HistoryActionType
   })
   public action!: HistoryActionType

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

@@ -17,7 +17,7 @@ export class FinancialStatementQuery {
 
   @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

@@ -42,7 +42,7 @@ export class FinancialStatement {
   version?: number = 1
 
   @ManyToOne(type => Domain)
-  @Field(type => Domain)
+  @Field({ nullable: true })
   domain?: Domain
 
   @RelationId((financialStatement: FinancialStatement) => financialStatement.domain)