@things-factory/accounting 8.0.0-beta.9 → 8.0.2

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 = [
+        // 유동자산 계정
+        {
+          code: '101',
+          name: '현금 및 현금성 자산',
+          description: '현금, 예금 및 기타 현금성 자산',
+          category: subCategories.유동자산
+        },
+        {
+          code: '102',
+          name: '매출채권',
+          description: '상품 또는 서비스의 판매로 인해 발생한 채권',
+          category: subCategories.유동자산
+        },
+        {
+          code: '103',
+          name: '재고자산',
+          description: '판매를 목적으로 보유한 상품, 제품, 원재료 등',
+          category: subCategories.유동자산
+        },
+        {
+          code: '104',
+          name: '단기금융상품',
+          description: '단기투자 목적으로 보유한 금융상품',
+          category: subCategories.유동자산
+        },
+        {
+          code: '105',
+          name: '선급금',
+          description: '상품, 서비스 제공을 위해 미리 지급한 금액',
+          category: subCategories.유동자산
+        },
+
+        // 비유동자산 계정
+        {
+          code: '201',
+          name: '건물',
+          description: '기업이 소유한 건물',
+          category: furtherSubCategories.유형자산
+        },
+        {
+          code: '202',
+          name: '토지',
+          description: '기업이 소유한 토지',
+          category: furtherSubCategories.유형자산
+        },
+        {
+          code: '203',
+          name: '기계장치',
+          description: '생산을 위해 사용되는 기계 및 장치',
+          category: furtherSubCategories.유형자산
+        },
+        {
+          code: '204',
+          name: '무형자산',
+          description: '특허권, 상표권 등의 무형자산',
+          category: furtherSubCategories.무형자산
+        },
+
+        // 유동부채 계정
+        {
+          code: '301',
+          name: '매입채무',
+          description: '상품 또는 서비스의 구매로 인해 발생한 채무',
+          category: subCategories.유동부채
+        },
+        {
+          code: '302',
+          name: '단기차입금',
+          description: '단기 대출금',
+          category: furtherSubCategories.단기금융부채
+        },
+        {
+          code: '303',
+          name: '미지급금',
+          description: '이미 발생한 비용에 대한 지급할 금액',
+          category: subCategories.유동부채
+        },
+        {
+          code: '304',
+          name: '선수금',
+          description: '고객으로부터 미리 받은 금액',
+          category: subCategories.유동부채
+        },
+
+        // 비유동부채 계정
+        { code: '401', name: '장기차입금', description: '장기 대출금', category: subCategories.비유동부채 },
+        {
+          code: '402',
+          name: '퇴직급여충당부채',
+          description: '퇴직급여 지급을 위해 설정한 부채',
+          category: subCategories.비유동부채
+        },
+
+        // 자본 계정
+        { code: '501', name: '자본금', description: '주주가 납입한 자본', category: topLevelCategories.자본 },
+        { code: '502', name: '이익잉여금', description: '이익의 축적', category: topLevelCategories.자본 },
+
+        // 수익 계정
+        {
+          code: '601',
+          name: '제품매출',
+          description: '제품의 판매로 인한 수익',
+          category: topLevelCategories.수익
+        },
+        {
+          code: '602',
+          name: '상품매출',
+          description: '상품의 판매로 인한 수익',
+          category: topLevelCategories.수익
+        },
+        {
+          code: '603',
+          name: '용역매출',
+          description: '용역 제공으로 인한 수익',
+          category: topLevelCategories.수익
+        },
+        {
+          code: '604',
+          name: '이자수익',
+          description: '금융 자산에서 발생한 이자수익',
+          category: topLevelCategories.수익
+        },
+        {
+          code: '605',
+          name: '배당금수익',
+          description: '주식 투자로 인한 배당금 수익',
+          category: topLevelCategories.수익
+        },
+
+        // 비용 계정
+        {
+          code: '701',
+          name: '매출원가',
+          description: '제품, 상품, 용역 제공에 대한 원가',
+          category: topLevelCategories.비용
+        },
+        { code: '702', name: '급여', description: '직원 급여 비용', category: topLevelCategories.비용 },
+        { code: '703', name: '임대료', description: '건물 및 설비 임차료', category: topLevelCategories.비용 },
+        {
+          code: '704',
+          name: '감가상각비',
+          description: '유형자산의 감가상각비용',
+          category: topLevelCategories.비용
+        },
+        {
+          code: '705',
+          name: '이자비용',
+          description: '차입금에 대한 이자비용',
+          category: topLevelCategories.비용
+        },
+        {
+          code: '706',
+          name: '판매비 및 관리비',
+          description: '기업 운영에 필요한 비용',
+          category: topLevelCategories.비용
+        },
+        { code: '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.softDelete({ domain: { id: domain.id } })
+
+    // AccountingCategories 삭제
+    await accountingCategoryRepository.softDelete({ domain: { id: domain.id } })
+  }
+}

package/server/migrations/index.ts

@@ -0,0 +1,9 @@
+const glob = require('glob')
+const path = require('path')
+
+export var migrations = []
+
+glob.sync(path.resolve(__dirname, '.', '**', '*.js')).forEach(function(file) {
+  if (file.indexOf('index.js') !== -1) return
+  migrations = migrations.concat(Object.values(require(path.resolve(file))) || [])
+})

package/server/routes.ts

@@ -0,0 +1,26 @@
+process.on('bootstrap-module-global-public-route' as any, (app, globalPublicRouter) => {
+  /*
+   * can add global public routes to application (auth not required, tenancy not required)
+   *
+   * ex) routes.get('/path', async(context, next) => {})
+   * ex) routes.post('/path', async(context, next) => {})
+   */
+})
+
+process.on('bootstrap-module-global-private-route' as any, (app, globalPrivateRouter) => {
+  /*
+   * can add global private routes to application (auth required, tenancy not required)
+   */
+})
+
+process.on('bootstrap-module-domain-public-route' as any, (app, domainPublicRouter) => {
+  /*
+   * can add domain public routes to application (auth not required, tenancy required)
+   */
+})
+
+process.on('bootstrap-module-domain-private-route' as any, (app, domainPrivateRouter) => {
+  /*
+   * can add domain private routes to application (auth required, tenancy required)
+   */
+})

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

@@ -0,0 +1,117 @@
+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 { Account } from './account'
+import { AccountingCategory } from '../accounting-category/accounting-category'
+
+const ORMCONFIG = config.get('ormconfig', {})
+const DATABASE_TYPE = ORMCONFIG.type
+
+@Entity()
+@Index(
+  'ix_account_history_0',
+  (accountHistory: AccountHistory) => [accountHistory.originalId, accountHistory.version],
+  { unique: true }
+)
+@Index(
+  'ix_account_history_1',
+  (accountHistory: AccountHistory) => [accountHistory.domain, accountHistory.originalId, accountHistory.version],
+  { unique: true }
+)
+@ObjectType({ description: 'History Entity of Account' })
+export class AccountHistory implements HistoryEntityInterface<Account> {
+  @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((accountHistory: AccountHistory) => accountHistory.domain)
+  domainId?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  code?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  name?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  description?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  active?: boolean
+
+  @ManyToOne(type => AccountingCategory)
+  @Field(type => AccountingCategory, { nullable: true })
+  category?: AccountingCategory
+
+  @RelationId((accountHistory: AccountHistory) => accountHistory.category)
+  categoryId?: 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({ nullable: true })
+  creator?: User
+
+  @RelationId((accountHistory: AccountHistory) => accountHistory.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field({ nullable: true })
+  updater?: User
+
+  @RelationId((accountHistory: AccountHistory) => accountHistory.updater)
+  updaterId?: string
+
+  @HistoryOriginalIdColumn()
+  public originalId!: string
+
+  @HistoryActionColumn({
+    nullable: false,
+    type:
+      DATABASE_TYPE == 'postgres' || DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb'
+        ? 'enum'
+        : DATABASE_TYPE == 'oracle'
+          ? 'varchar2'
+          : DATABASE_TYPE == 'mssql'
+            ? 'nvarchar'
+            : 'varchar',
+    enum:
+      DATABASE_TYPE == 'postgres' || DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb'
+        ? HistoryActionType
+        : undefined,
+    length: DATABASE_TYPE == 'postgres' || DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb' ? undefined : 10
+  })
+  public action!: HistoryActionType
+}

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

@@ -0,0 +1,140 @@
+import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
+import { In } from 'typeorm'
+
+import { getRepository } from '@things-factory/shell'
+
+import { Account } from './account'
+import { NewAccount, AccountPatch } from './account-type'
+
+@Resolver(Account)
+export class AccountMutation {
+  @Directive('@transaction')
+  @Directive('@privilege(category: "accounting", privilege: "mutation")')
+  @Mutation(returns => Account, { description: 'To create new Account' })
+  async createAccount(@Arg('account') account: NewAccount, @Ctx() context: ResolverContext): Promise<Account> {
+    const { domain, user, tx } = context.state
+
+    const result = await getRepository(Account, tx).save({
+      ...account,
+      domain,
+      creator: user,
+      updater: user
+    })
+
+    return result
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(category: "accounting", privilege: "mutation")')
+  @Mutation(returns => Account, { description: 'To modify Account information' })
+  async updateAccount(
+    @Arg('id') id: string,
+    @Arg('patch') patch: AccountPatch,
+    @Ctx() context: ResolverContext
+  ): Promise<Account> {
+    const { domain, user, tx } = context.state
+
+    const repository = getRepository(Account, tx)
+    const account = await repository.findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+
+    const result = await repository.save({
+      ...account,
+      ...patch,
+      updater: user
+    })
+
+    return result
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(category: "accounting", privilege: "mutation")')
+  @Mutation(returns => [Account], { description: "To modify multiple Accounts' information" })
+  async updateMultipleAccount(
+    @Arg('patches', type => [AccountPatch]) patches: AccountPatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<Account[]> {
+    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 accountRepo = getRepository(Account, tx)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await accountRepo.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 account = await accountRepo.findOneBy({ id: updateRecord.id })
+
+        const result = await accountRepo.save({
+          ...account,
+          ...updateRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(category: "accounting", privilege: "mutation")')
+  @Mutation(returns => Boolean, { description: 'To delete Account' })
+  async deleteAccount(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await getRepository(Account, tx).delete({ domain: { id: domain.id }, id })
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(category: "accounting", privilege: "mutation")')
+  @Mutation(returns => Boolean, { description: 'To delete multiple Accounts' })
+  async deleteAccounts(@Arg('ids', type => [String]) ids: string[], @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await getRepository(Account, tx).delete({
+      domain: { id: domain.id },
+      id: In(ids)
+    })
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(category: "accounting", privilege: "mutation")')
+  @Mutation(returns => Boolean, { description: 'To import multiple Accounts' })
+  async importAccounts(
+    @Arg('accounts', type => [AccountPatch]) accounts: AccountPatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await Promise.all(
+      accounts.map(async (account: AccountPatch) => {
+        const createdAccount: Account = await getRepository(Account, tx).save({ domain, ...account })
+      })
+    )
+
+    return true
+  }
+}

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

@@ -0,0 +1,51 @@
+import { Resolver, Query, FieldResolver, Root, Args, Arg, Ctx, Directive } from 'type-graphql'
+
+import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { Account } from './account'
+import { AccountList } from './account-type'
+
+@Resolver(Account)
+export class AccountQuery {
+  @Directive('@privilege(category: "accounting", privilege: "query")')
+  @Query(returns => Account!, { nullable: true, description: 'To fetch a Account' })
+  async account(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Account> {
+    const { domain } = context.state
+
+    return await getRepository(Account).findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+  }
+
+  @Directive('@privilege(category: "accounting", privilege: "query")')
+  @Query(returns => AccountList, { description: 'To fetch multiple Accounts' })
+  async accounts(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<AccountList> {
+    const { domain } = context.state
+
+    const queryBuilder = getQueryBuilderFromListParams({
+      domain,
+      params,
+      repository: await getRepository(Account),
+      searchables: ['name', 'description']
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() account: Account): Promise<Domain> {
+    return await getRepository(Domain).findOneBy({ id: account.domainId })
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() account: Account): Promise<User> {
+    return await getRepository(User).findOneBy({ id: account.updaterId })
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() account: Account): Promise<User> {
+    return await getRepository(User).findOneBy({ id: account.creatorId })
+  }
+}