@things-factory/accounting 8.0.39 → 9.0.0-9.0.0-beta.59.0

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

@@ -1,339 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,117 +0,0 @@
-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

@@ -1,140 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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 })
-  }
-}