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

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

@@ -0,0 +1,139 @@
+import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
+import { In } from 'typeorm'
+import { getRepository } from '@things-factory/shell'
+
+import { Payment } from './payment'
+import { NewPayment, PaymentPatch } from './payment-type'
+
+@Resolver(Payment)
+export class PaymentMutation {
+  @Directive('@transaction')
+  @Directive('@privilege(category: "accounting", privilege: "mutation")')
+  @Mutation(returns => Payment, { description: 'To create new Payment' })
+  async createPayment(@Arg('payment') payment: NewPayment, @Ctx() context: ResolverContext): Promise<Payment> {
+    const { domain, user, tx } = context.state
+
+    const result = await getRepository(Payment, tx).save({
+      ...payment,
+      domain,
+      creator: user,
+      updater: user
+    })
+
+    return result
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(category: "accounting", privilege: "mutation")')
+  @Mutation(returns => Payment, { description: 'To modify Payment information' })
+  async updatePayment(
+    @Arg('id') id: string,
+    @Arg('patch') patch: PaymentPatch,
+    @Ctx() context: ResolverContext
+  ): Promise<Payment> {
+    const { domain, user, tx } = context.state
+
+    const repository = getRepository(Payment, tx)
+    const payment = await repository.findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+
+    const result = await repository.save({
+      ...payment,
+      ...patch,
+      updater: user
+    })
+
+    return result
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(category: "accounting", privilege: "mutation")')
+  @Mutation(returns => [Payment], { description: "To modify multiple Payments' information" })
+  async updateMultiplePayment(
+    @Arg('patches', type => [PaymentPatch]) patches: PaymentPatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<Payment[]> {
+    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 paymentRepo = getRepository(Payment, tx)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await paymentRepo.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 payment = await paymentRepo.findOneBy({ id: updateRecord.id })
+
+        const result = await paymentRepo.save({
+          ...payment,
+          ...updateRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(category: "accounting", privilege: "mutation")')
+  @Mutation(returns => Boolean, { description: 'To delete Payment' })
+  async deletePayment(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await getRepository(Payment, tx).delete({ domain: { id: domain.id }, id })
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(category: "accounting", privilege: "mutation")')
+  @Mutation(returns => Boolean, { description: 'To delete multiple Payments' })
+  async deletePayments(@Arg('ids', type => [String]) ids: string[], @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await getRepository(Payment, 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 Payments' })
+  async importPayments(
+    @Arg('payments', type => [PaymentPatch]) payments: PaymentPatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await Promise.all(
+      payments.map(async (payment: PaymentPatch) => {
+        const createdPayment: Payment = await getRepository(Payment, tx).save({ domain, ...payment })
+      })
+    )
+
+    return true
+  }
+}

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

@@ -0,0 +1,50 @@
+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 { Payment } from './payment'
+import { PaymentList } from './payment-type'
+
+@Resolver(Payment)
+export class PaymentQuery {
+  @Directive('@privilege(category: "accounting", privilege: "query")')
+  @Query(returns => Payment!, { nullable: true, description: 'To fetch a Payment' })
+  async payment(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Payment> {
+    const { domain } = context.state
+
+    return await getRepository(Payment).findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+  }
+
+  @Directive('@privilege(category: "accounting", privilege: "query")')
+  @Query(returns => PaymentList, { description: 'To fetch multiple Payments' })
+  async payments(@Args(type => ListParam) params: ListParam, @Ctx() context: ResolverContext): Promise<PaymentList> {
+    const { domain } = context.state
+
+    const queryBuilder = getQueryBuilderFromListParams({
+      domain,
+      params,
+      repository: await getRepository(Payment),
+      searchables: []
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() payment: Payment): Promise<Domain> {
+    return payment.domainId && (await getRepository(Domain).findOneBy({ id: payment.domainId }))
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() payment: Payment): Promise<User> {
+    return payment.updaterId && (await getRepository(User).findOneBy({ id: payment.updaterId }))
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() payment: Payment): Promise<User> {
+    return payment.creatorId && (await getRepository(User).findOneBy({ id: payment.creatorId }))
+  }
+}

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

@@ -0,0 +1,82 @@
+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 { Payment, PaymentDirection, PaymentType } from './payment'
+
+@InputType()
+export class NewPayment {
+  @Field(type => ObjectRef)
+  transaction: ObjectRef
+
+  @Field({ nullable: true })
+  currency?: string
+
+  @Field({ nullable: false })
+  amount: number
+
+  @Field({ nullable: false })
+  paidAt: Date
+
+  @Field(type => PaymentDirection)
+  direction: PaymentDirection
+
+  @Field(type => PaymentType, { description: 'Type of the payment' })
+  paymentType: PaymentType // 결제 유형
+
+  @Field(type => ObjectRef, { nullable: true, description: 'Source bank account for the payment' })
+  sourceBankAccount?: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true, description: 'Destination bank account for the payment' })
+  destinationBankAccount?: ObjectRef
+
+  @Field({ nullable: true })
+  note?: string
+}
+
+@InputType()
+export class PaymentPatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field(type => ObjectRef)
+  transaction: ObjectRef
+
+  @Field({ nullable: true })
+  currency?: string
+
+  @Field({ nullable: false })
+  amount: number
+
+  @Field({ nullable: false })
+  paidAt: Date
+
+  @Field(type => PaymentDirection)
+  direction: PaymentDirection
+
+  @Field(type => PaymentType, { description: 'Type of the payment' })
+  paymentType: PaymentType // 결제 유형
+
+  @Field(type => ObjectRef, { nullable: true, description: 'Source bank account for the payment' })
+  sourceBankAccount?: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true, description: 'Destination bank account for the payment' })
+  destinationBankAccount?: ObjectRef
+
+  @Field({ nullable: true })
+  note?: string
+
+  @Field({ nullable: true })
+  cuFlag?: string
+}
+
+@ObjectType()
+export class PaymentList {
+  @Field(type => [Payment])
+  items: Payment[]
+
+  @Field(type => Int)
+  total: number
+}

package/server/service/payment/payment.ts

@@ -0,0 +1,154 @@
+import {
+  CreateDateColumn,
+  UpdateDateColumn,
+  DeleteDateColumn,
+  Entity,
+  Index,
+  Column,
+  RelationId,
+  ManyToOne,
+  VersionColumn,
+  PrimaryGeneratedColumn
+} from 'typeorm'
+import { ObjectType, Field, ID, registerEnumType } from 'type-graphql'
+
+import { Domain } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { Transaction } from '../transaction/transaction'
+import { BankAccount } from 'service/bank-account/bank-account'
+
+export enum PaymentDirection {
+  Incoming = 'Incoming', // 수금
+  Outgoing = 'Outgoing' // 지출
+}
+
+registerEnumType(PaymentDirection, {
+  name: 'PaymentDirection',
+  description: 'Indicates whether the payment is incoming (received) or outgoing (paid)' // 결제 방향을 나타냅니다 (수금 또는 지출)
+})
+
+export enum PaymentType {
+  Transfer = 'Transfer', // 계좌 이체
+  Cash = 'Cash', // 현금
+  CreditCard = 'CreditCard', // 신용카드
+  DebitCard = 'DebitCard' // 직불카드
+}
+
+registerEnumType(PaymentType, {
+  name: 'PaymentType',
+  description: 'Type of the payment (e.g., Transfer, Cash, CreditCard, DebitCard)' // 결제 유형을 나타냅니다
+})
+
+@Entity()
+@Index('ix_payment_0', (payment: Payment) => [payment.domain, payment.transaction, payment.paidAt], {
+  where: '"deleted_at" IS NULL',
+  unique: true
+})
+@Index(
+  'ix_payment_1',
+  (payment: Payment) => [payment.domain, payment.year, payment.quarter, payment.month, payment.paidAt],
+  {
+    unique: true,
+    where: '"deleted_at" IS NULL'
+  }
+)
+@ObjectType({ description: 'Entity representing a Payment record in the system' }) // 시스템 내에서 결제 기록을 나타내는 엔티티
+export class Payment {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID, { description: 'Unique identifier for the payment record' })
+  readonly id: string // 고유 식별자 (UUID)
+
+  @VersionColumn()
+  @Field({ nullable: true, description: 'Version number used for optimistic locking' })
+  version?: number = 1 // 낙관적 잠금을 위한 버전 관리 필드
+
+  @ManyToOne(type => Domain)
+  @Field({ nullable: true, description: 'The domain to which this payment belongs' })
+  domain?: Domain // 결제가 속한 도메인
+
+  @RelationId((payment: Payment) => payment.domain)
+  domainId?: string // 도메인의 ID
+
+  @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 // 결제에 대한 추가 설명 또는 메모
+
+  @CreateDateColumn()
+  @Field({ nullable: true, description: 'The date and time when the payment record was created' })
+  createdAt?: Date // 결제 레코드가 생성된 날짜 및 시간
+
+  @UpdateDateColumn()
+  @Field({ nullable: true, description: 'The date and time when the payment record was last updated' })
+  updatedAt?: Date // 결제 레코드가 마지막으로 업데이트된 날짜 및 시간
+
+  @DeleteDateColumn()
+  @Field({ nullable: true, description: 'The date and time when the payment record was deleted' })
+  deletedAt?: Date // 결제 레코드가 삭제된 날짜 및 시간
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true, description: 'The user who created the payment record' })
+  creator?: User // 결제 레코드를 생성한 사용자
+
+  @RelationId((payment: Payment) => payment.creator)
+  creatorId?: string // 결제 레코드를 생성한 사용자의 ID
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true, description: 'The user who last updated the payment record' })
+  updater?: User // 결제 레코드를 마지막으로 업데이트한 사용자
+
+  @RelationId((payment: Payment) => payment.updater)
+  updaterId?: string // 결제 레코드를 업데이트한 사용자의 ID
+}

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

@@ -11,7 +11,7 @@ import { Role, User } from '@things-factory/auth-base'
 import { config } from '@things-factory/env'
 import { Domain } from '@things-factory/shell'
 
-import { Transaction, TransactionType } from './transaction'
+import { Transaction, TransactionCategory, TransactionStatus, TransactionType } from './transaction'
 import { Account } from '../account/account'
 
 const ORMCONFIG = config.get('ormconfig', {})
@@ -46,7 +46,7 @@ export class TransactionHistory implements HistoryEntityInterface<Transaction> {
   @Field({ nullable: true })
   domain?: Domain
 
-  @RelationId((transaction: Transaction) => transaction.domain)
+  @RelationId((transactionHistory: TransactionHistory) => transactionHistory.domain)
   domainId?: string
 
   @Column()
@@ -73,11 +73,27 @@ export class TransactionHistory implements HistoryEntityInterface<Transaction> {
   @Field({ nullable: true })
   type?: TransactionType
 
+  @Column({ nullable: false })
+  @Field(type => TransactionCategory, { nullable: false })
+  category: TransactionCategory // 트랜잭션의 카테고리 (확정, 전망)
+
+  @Column({ nullable: false })
+  @Field(type => TransactionStatus, { nullable: false })
+  status: TransactionStatus // 트랜잭션의 상태 (예: Paid, Delayed 등)
+
+  @Column({ nullable: true })
+  @Field({ nullable: true, description: 'The probability of the forecast being realized (0 to 100)' })
+  probability?: number // 예측이 실현될 확률 (0 ~ 100)
+
+  @Column({ nullable: true })
+  @Field({ nullable: true, description: 'Additional notes or comments about the forecast' })
+  forecastNotes?: string // 전망에 대한 추가 설명이나 메모
+
   @ManyToOne(type => Account)
   @Field({ nullable: true })
   account?: Account
 
-  @RelationId((transaction: Transaction) => transaction.account)
+  @RelationId((transactionHistory: TransactionHistory) => transactionHistory.account)
   accountId?: string
 
   @Column({ nullable: true })
@@ -92,9 +108,9 @@ export class TransactionHistory implements HistoryEntityInterface<Transaction> {
   @Field({ nullable: true, description: 'fiscal month' })
   month?: number
 
-  @Column({ type: 'timestamp', nullable: false })
-  @Field({ nullable: false, description: 'The exact date and time the transaction occurred' })
-  occurredAt: Date // 트랜잭션이 발생한 실제 시점(날짜와 시간)
+  @Column({ nullable: false })
+  @Field({ nullable: false, description: 'The date the transaction occurs or is scheduled (in string format)' })
+  transactionDate: string // 트랜잭션이 발생하거나 발생할 날짜
 
   @Column()
   @Field({ nullable: true })
@@ -112,14 +128,14 @@ export class TransactionHistory implements HistoryEntityInterface<Transaction> {
   @Field(type => User, { nullable: true })
   creator?: User
 
-  @RelationId((transaction: Transaction) => transaction.creator)
+  @RelationId((transactionHistory: TransactionHistory) => transactionHistory.creator)
   creatorId?: string
 
   @ManyToOne(type => User, { nullable: true })
   @Field(type => User, { nullable: true })
   updater?: User
 
-  @RelationId((transaction: Transaction) => transaction.updater)
+  @RelationId((transactionHistory: TransactionHistory) => transactionHistory.updater)
   updaterId?: string
 
   @HistoryOriginalIdColumn()

package/server/service/transaction/transaction-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 { Transaction } from './transaction'
 import { NewTransaction, TransactionPatch } from './transaction-type'
@@ -9,6 +9,7 @@ import { NewTransaction, TransactionPatch } from './transaction-type'
 @Resolver(Transaction)
 export class TransactionMutation {
   @Directive('@transaction')
+  @Directive('@privilege(category: "accounting", privilege: "mutation")')
   @Mutation(returns => Transaction, { description: 'To create new Transaction' })
   async createTransaction(
     @Arg('transaction') transaction: NewTransaction,
@@ -16,7 +17,7 @@ export class TransactionMutation {
   ): Promise<Transaction> {
     const { domain, user, tx } = context.state
 
-    const result = await tx.getRepository(Transaction).save({
+    const result = await getRepository(Transaction, tx).save({
       ...transaction,
       domain,
       creator: user,
@@ -27,6 +28,7 @@ export class TransactionMutation {
   }
 
   @Directive('@transaction')
+  @Directive('@privilege(category: "accounting", privilege: "mutation")')
   @Mutation(returns => Transaction, { description: 'To modify Transaction information' })
   async updateTransaction(
     @Arg('id') id: string,
@@ -35,7 +37,7 @@ export class TransactionMutation {
   ): Promise<Transaction> {
     const { domain, user, tx } = context.state
 
-    const repository = tx.getRepository(Transaction)
+    const repository = getRepository(Transaction, tx)
     const transaction = await repository.findOne({
       where: { domain: { id: domain.id }, id }
     })
@@ -50,6 +52,7 @@ export class TransactionMutation {
   }
 
   @Directive('@transaction')
+  @Directive('@privilege(category: "accounting", privilege: "mutation")')
   @Mutation(returns => [Transaction], { description: "To modify multiple Transactions' information" })
   async updateMultipleTransaction(
     @Arg('patches', type => [TransactionPatch]) patches: TransactionPatch[],
@@ -60,7 +63,7 @@ export class TransactionMutation {
     let results = []
     const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
     const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
-    const transactionRepo = tx.getRepository(Transaction)
+    const transactionRepo = getRepository(Transaction, tx)
 
     if (_createRecords.length > 0) {
       for (let i = 0; i < _createRecords.length; i++) {
@@ -96,17 +99,18 @@ export class TransactionMutation {
   }
 
   @Directive('@transaction')
+  @Directive('@privilege(category: "accounting", privilege: "mutation")')
   @Mutation(returns => Boolean, { description: 'To delete Transaction' })
   async deleteTransaction(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
     const { domain, tx } = context.state
 
-    await tx.getRepository(Transaction).delete({ domain: { id: domain.id }, id })
-    await deleteAttachmentsByRef(null, { refBys: [id] }, context)
+    await getRepository(Transaction, tx).delete({ domain: { id: domain.id }, id })
 
     return true
   }
 
   @Directive('@transaction')
+  @Directive('@privilege(category: "accounting", privilege: "mutation")')
   @Mutation(returns => Boolean, { description: 'To delete multiple Transactions' })
   async deleteTransactions(
     @Arg('ids', type => [String]) ids: string[],
@@ -114,17 +118,16 @@ export class TransactionMutation {
   ): Promise<boolean> {
     const { domain, tx } = context.state
 
-    await tx.getRepository(Transaction).delete({
+    await getRepository(Transaction, 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 Transactions' })
   async importTransactions(
     @Arg('transactions', type => [TransactionPatch]) transactions: TransactionPatch[],
@@ -134,7 +137,7 @@ export class TransactionMutation {
 
     await Promise.all(
       transactions.map(async (transaction: TransactionPatch) => {
-        const createdTransaction: Transaction = await tx.getRepository(Transaction).save({ domain, ...transaction })
+        const createdTransaction: Transaction = await getRepository(Transaction, tx).save({ domain, ...transaction })
       })
     )
 

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

@@ -6,6 +6,7 @@ import { TransactionList } from './transaction-type'
 
 @Resolver(Transaction)
 export class TransactionQuery {
+  @Directive('@privilege(category: "accounting", privilege: "query")')
   @Query(returns => Transaction!, { nullable: true, description: 'To fetch a Transaction' })
   async transaction(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Transaction> {
     const { domain } = context.state
@@ -15,6 +16,7 @@ export class TransactionQuery {
     })
   }
 
+  @Directive('@privilege(category: "accounting", privilege: "query")')
   @Query(returns => TransactionList, { description: 'To fetch multiple Transactions' })
   async transactions(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<TransactionList> {
     const { domain } = context.state