現状のユーザー情報更新の流れ

現状のユーザー情報更新までの流れはこんな感じになっています。

まずユーザー情報のアイコン画像をStorageに保存して、そのパスとユーザー情報をFirestoreに更新します。その後、更新したユーザー情報をもとに一部の情報ブラウザのLocalStorageにするような流れになっています。

データの流れは基本的に画面がから受け取った値を横流しにしている感じになっており、アプリケーションとしての役割や領域が曖昧になってしまっています。また、アーキテクチャとしても簡易的なClean Architectureになっており、責務がしっかりと分けきれていない感じがしました。

そこで、この辺りの記事をあらためて読み返して、アプリケーションとしてのユースケースやコアドメインを洗い出しました。

【Typescript】Clean Architecture + DDDでAPIを実装してみた

Typescript + ​​Clean Architecture + DDDで…

mintaku-blog.net

ユーザー情報更新のデータの流れや構成をこうしたい

ということで、自分の中で色々整理して、理想のアーキテクチャやデータフロー（データの型は簡易的にしています）を考えてみました。

まずは、ドメインやエンティティとして領域ごとに型を用意しました。アプリケーションのコアとなる部分ではドメインとして扱い、サードパーティーなどを操作するDriver層ではエンティティとして扱うようにしました。

アプリケーションと外部の境界のGateway/Presenterにてデータの変換を行うようにします。また、Contoller層を用意し、Usecaseにドメインの型で渡すようにします。

まだまだかもですが、これでだいぶ責務の切り分けはできてきたかと思います。きっちりやろうとするとコード量が増えますが、コアなユースケースなので安全かつ複雑性を排除して、keep cleanの精神でリファクタリングしていきたいです。

まとめ

最近あんまりガッツリ開発に携わってないと、新鮮な目で設計とかリアーキ考えることができ、良い機会になりました。

あと考えていくうちに疑問点とか色々出てくるので、色んな人に聞いたり、議論しながらもっとブラッシュアップしてきたいと思いました。

他にもリファクタリングしたいところは多々あるので、コツコツやっていきたいと思います。

背景

自分が作ったWebサービスは、元々メディア的な属性が強かったのですが、認証機能やCRUDする機能など動的な機能が増えてきて、ロジック部分が多くなり複雑化してきました。

また、サーバーレスということもありフロントでのコード量が増え、なんとかアーキテクチャを見直さないと大変そうな感じがしていました。

そして一番の理由がテストが書きづらいかったところです。元々メディア的な運営の仕方でSSGしていたこともあり、ほぼ静的ページであったため、デプロイ前のgenerateがテスト代わりのようになっていました。

しかし、動的な機能が増えるとSSGでは検知できないため、テストを書く必要があり、いざ書こうと思うと非常に書きにく設計となっていました。

今後の運用性・拡張性を考えてもリアーキテクチャは急務であり、非常に優先度の高い重要なタスクとして取り掛かりました。

色々考えたことを整理する

・フレームワークに依存した作りをやめたい

・レイヤリングしたい

・DIしたい

・UTの導入

・ライブラリに依存したドメインを使わないようにしたい

・共通化したい

・型エラー直したい

ざっくりこんなことを考えており、1つ1つこなしていきました。感覚的な意識の部分としては、「依存性をなくして抽象的かつ中長期的に開発生産性の高いものにしたい」ということをぼんやり考えてました。

そんな中で、Nuxt3 + TypeScriptで開発しているのですが、ロジック部分などなるべくフレームワークに依存するような書き方はやめたいと考え、テストの書きにくさだったり、汎用性だったりを考えたときに、なるべく抽象性の高い書き方にしたく、素のTypeScriptで書くようにしました。

また、ドメインに関する情報の増加や複雑性もあり、DDD + Clean Architectureを導入することにしました。一部Firebaseライブラリのドメインを使っていましたが、そこへの依存度が高くなってしまい、Firebaseを辞めたときやバージョンアップで気付かぬうちに使えなくなってたというのをなくしたい気持ちがありました。

その上で、JestによるUTを導入し、安全かつ見通しの良い、開発していて楽しい開発体験を目指しました。

今回は、DDD + Clean Architectureを導入したリアーキテクチャのところを一部まとめておきたいと思います。

DDD + Clean Architectureの導入してリアーキテクチャする

構成としてはこんな感じで、srcの下にそれぞれレイヤリングして配置しています。modules.tsに依存関係を書いています。

依存関係としてはusecaseはgatewayとpresenterに依存しており、gatewaはdriverに依存しているといった形です。

本当はportなどのインターフェイスを作って依存性逆転して綺麗な形にしたいのですが、一旦このような形になっています。

usecaseではビジネスロジックを記述しており、garewayを通してデータの取得や登録などをしています。また、presenterを経由してstateの管理をしています。

gatewayではusecaseとdriverの橋渡しとして、driverからのデータをdomainに変換したりしています。データの取得・登録の実装部分はdriverで書いています。DBやAPIなど変更したとしても、driverを変えれば影響がないようにdriverからentityに詰めてgatewayに返すようにし、gatewayでdomainに詰め替えるようにしているところです。

ここまでレイヤリングすると、あとはusecaseを呼び出すだけで済むので、だいぶスッキリしました。

今後はTDDで進めたいと思っていますが、既存の部分に関してはガッとリアーキテクチャしてから、テスト書きました。テストはJestを使っており、jest-whenライブラリを活用しつつ書いています。

今後について

一旦基盤はできたので、今後は適宜リファクタリングしながら、保守性の高い設計に向けて改善を続けたいと思っています。

ドメインも全部なかったりまだ伸び代もあるので、常に改善する気持ちで開発し続けることが大事になりそうです。

あとはSSGベースでやってますが、SSRにしていきたい感あります。ちょっとコスト的にどれだけ高くなるのか心配ですが、チャレンジしたいと思っています。

あとE2Eも書きたいと思っています。Cypressでちょっとやりましたが、放置してしまってるので、どこかで本腰入れてやりたいと思っています。やはりテストで担保されていないと、いつ壊れるかわからないですし、そうした状況下で開発するのは結構しんどいと思います。

品質の担保かつ生産性の向上のためにも、よりより開発・設計を追求していきたいです。

今のざっくりアーキテクチャ図

こちらの記事で書いてありますが、元々Netlifyを使用していましたが、Firebase Hostingに移行しました。

NetlifyからFirebase Hostingに移行した話

満を辞して？NetlifyからFirebase Hostingに移行したので、メ…

mintaku-blog.net

基本SSGの構成は変わっておらず、後で説明しますが、一部SPA的なページが追加されました。

流れとしてはmainブランチにプッシュされるとGithub Actionsのパイプラインが動き出し、ビルドが始まります。

ビルド時はContenfulからデータを取得して、静的なページを生成していきます。ページの生成が完了すると、Firebase Hostingにデプロイします。

ページ数は今のところ大体3300ページくらいあり、ビルドしてデプロイするまで20分近くかかっており、長すぎるビルド時間が直近の課題となっています。

今考えているアプローチ方法は、ISGの導入や最近Nuxt3機能追加されたpayloadを使うなど、サーバー通信を減らしていきたいと思っています。

認証機能のところ

今回新しく追加した認証機能はFirebase Authenticationを使いました。Firebaseに統合したいのもあって、ホスティングサービスもNetlifyからFirebase Hostingに移行した感じです。

1stリリースでは、認証のプロバイダはGoogleとTwitterのみにしています。後々、メールアドレスや他のSNS認証も追加する予定です。

ユーザー情報などの格納データはFirestoreを使っています。Firebase Authenticationとあわせて開発しやすかったです。

今後のアーキテクチャについて

今後の開発において、ますます動的な機能が増えていくと思います。今はサーバーレスのSSGで開発していますが、後々はAPIを立てたり、SSRに変更するなど考えています。

新しい技術なども出てきたりすると思うので、臨機応変にその時その時考えて、アーキテクチャや使用技術を決めていきたいと思います。

また、負債を残さないためにもdependabotの導入によるライブラリのバージョンアップやこまめなリファクタリングなど、開発生産性を高く保ちながらより良いサービスを提供していきたいです。

• Kotlin: 1.6.10
• SpringBoot: 2.4.4

Spring BootでのDI

そもそもDIとはDependeny Injectionの略で依存性の注入という意味です。DIはオブジェクト間に生じる依存関係をオブジェクト内のコードに直接記述せず、外部から何らかの形で与えるようにする手法です。

@Component

クラスにComponentアノテーションを付与するとDIの対象であることを表します。
そのクラスをDIコンテナが管理してくれるようになります。

他にも@Controllerや@Serviceがありますが、以下の使い分けをします。

• @Controller： MVCでコントローラー層のクラスに付与
• @Service： MVCでサービス層のクラスに付与
• @Repository： MVCでデータ層のクラスに付与
• @Component： MVCに限らず、DIで利用したいクラスへ付与する

@Bean

付与した関数で返却したインスタンスがDIコンテナに登録され、そのインスタンスをDIで使用できるようになります。

@Componentと@Beanの使い分けは以下の記事が参考になりました。

Spring Bootの@Componentと@Beanの違い - grep Tips *

まずは結論から SpringのDIコンテナに管理してもらいたいクラスが、自分で作…

www.greptips.com

@Autowired

注入されるフィールドに付けます。

DIコンテナはAutowiredアノテーションを付けたフィールドに対して、合致するオブジェクトを探してインジェクションします。

lateinit var

このフィールドへのインジェクションは変数の読み込みと同時に初期化されるのではなく、後からインジェクションされるためvar定義しておく必要があります。

Clean ArchitectureでTODOアプリを意識したAPIを実装してみる

Clean ArchitectureでTODOアプリを意識したAPIを実装してみました。といってもDBも用意せずスタブみたいな感じにしています。メソッドもgetTasks()とgetTask()だけでちょっとしたAPIとなっています。

Enterprise Business Rules

Enterprise Business Rulesではアプリケーション全体の最重要ビジネスルールをカプセル化したドメインを格納しています。

今回はTODOアプリを意識しているので、タスクIDとタイトル、コンテンツを含むTaskドメインとListとで持つTasksドメインを作っています。

・Task.kt

package com.example.domain

data class TaskId(val value: Int)

data class Title(val value: String)

data class Content(val value: String)

data class Task(val title: Title, val content: Content)

data class Tasks(val list: List<Task>)

Application Business Rules

Application Business Rulesではアプリケーション固有のビジネスルールが含まれ、入出力するデータの流れを調整します。

TaskPortにインターフェイスを定義し、TaskGatewayで具象クラスを実装するようにしています。TaskUseCaseではTaskPortを呼び出すように実装しています。

・TaskPort.kt

package com.example.port

import com.example.domain.Task
import com.example.domain.TaskId
import com.example.domain.Tasks

interface TaskPort {
  fun getTasks(): Tasks
  fun getTask(taskId: TaskId): Task
}

・TaskUseCase.kt

package com.example.usecase

import com.example.domain.Task
import com.example.domain.TaskId
import com.example.port.TaskPort
import com.example.domain.Tasks
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.stereotype.Component

@Component
class TaskUseCase() {
  @Autowired
  lateinit var taskPort: TaskPort

  fun getTasks(): Tasks {
    return taskPort.getTasks()
  }

  fun getTask(taskId: TaskId): Task {
    return taskPort.getTask(taskId)
  }

}

Interface & Adapter

Interface & Adapterではドメインやユースケースに便利な形式からDBに便利な形式にデータを変換します。

TaskGatewayはTaskPortで定義したinterfaceを実装しています。またTaskDriverで取得したJSONをドメインに変換する処理をしています。

TaskControllerでは逆にドメインをレスポンスの形に変換する処理をしています。

・TaskGateway.kt

package com.example.gateway

import com.example.domain.*
import com.example.driver.TaskDriver
import com.example.driver.TaskJson
import com.example.driver.TasksJson
import com.example.port.TaskPort
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.stereotype.Component

@Component
class TaskGateway: TaskPort {
  @Autowired
  lateinit var taskDriver: TaskDriver

  override fun getTasks(): Tasks {
    val tasksJson: TasksJson = taskDriver.getTasks()
    return tasksJson.toTasks()
  }

  override fun getTask(taskId: TaskId): Task {
    val taskJson: TaskJson = taskDriver.getTask(taskId.value)
    return taskJson.toTask()
  }
}

fun TasksJson.toTasks(): Tasks {
  return this.list.map {
    Task(Title(it.title), Content(it.content))
  }.let(::Tasks)
}

fun TaskJson.toTask(): Task {
  return Task(Title(this.title), Content(this.content))
}

・TaskController.kt

package com.example.controller

import org.springframework.beans.factory.annotation.Autowired
import org.springframework.web.bind.annotation.RestController
import com.example.usecase.TaskUseCase
import com.example.domain.Tasks
import com.example.domain.Task
import com.example.domain.TaskId
import org.springframework.http.ResponseEntity
import org.springframework.web.bind.annotation.GetMapping
import org.springframework.web.bind.annotation.PathVariable

@RestController
class TaskController {
  @Autowired
  lateinit var taskUseCase: TaskUseCase

  @GetMapping(value = ["/api/tasks"])
    fun getTasks(): ResponseEntity<TasksJson> {
    return ResponseEntity.ok(taskUseCase.getTasks().toJson())
  }

  @GetMapping(value = ["/api/tasks/{taskId}"])
  fun getTask(
    @PathVariable(value = "taskId", required = true) taskId: Int
  ): ResponseEntity<TaskJson> {
    return ResponseEntity.ok(taskUseCase.getTask(TaskId(taskId)).toJson())
  }
}

data class TaskJson(val title: String, val content: String)
data class TasksJson(val tasks: List<TaskJson>)

fun Tasks.toJson() = this.list.map { it.toJson() }.let(::TasksJson)
fun Task.toJson() = TaskJson(this.title.value, this.content.value)

Framework & Driver

Framework & Driverはフレームワークやツールで構成されています。

今回はスタブでJSON形式の値を返すようにしていますが、本来ならDB操作やAPIリクエストを行う想定です。

・TaskDriver.kt

package com.example.driver

import com.fasterxml.jackson.annotation.JsonCreator
import org.springframework.stereotype.Component

@Component
class TaskDriver() {
  fun getTasks(): TasksJson {
    return TasksJson(listOf(TaskJson("title", "content"), TaskJson("title2", "content2")))
  }

  fun getTask(taskId: Int): TaskJson {
    return TaskJson("title", "content")
  }
}

data class TasksJson @JsonCreator constructor(
  val list: List<TaskJson>
)

data class TaskJson @JsonCreator constructor(
  val title: String,
  val content: String
)

【Typescript】Clean Architecture + DDDでAPIを実装してみた

Typescript + ​​Clean Architecture + DDDで…

mintaku-blog.net

Jestを導入する

本来ならTDD的にテストを書いてから実装するのですが、元々の目的がClean Architecture + DDDのAPIをつくるのが目的だったため、後からテストを導入することになりました。

APIはTypescriptで実装されているため、Jestを導入しました。また前回同様、本記事ではメンバー関連を中心に取り扱います。APIしか作ってないのでE2EはなくUnitテストのみです。

型のモックの実現

テストにおいて型のモックは型を抽象化するジェネリックを使って実現します。特に実値で書く必要のない値に関してはモックを使用しています。

export function mock<T>(): T {
  return ({} as unknown) as T
}

Domainのテスト

ドメインのテストを書いていきます。

バリデーションやドメインへの変換処理などをテストしていきます。誕生日から年齢を取得するドメインメソッドのテストは現在日から取得しているため1年経つとテストが落ちるようになってしまうのが悩みどころです。上手い具合にテストできればいいのですが。。

・Member.spec.ts

import { Member, MemberBirthday, MemberGender, MemberId, MemberName, MemberProfile } from '../Member'
import { MemberRelation, MemberRelationAttribute } from '../MemberRelation'
import { DepartmentId } from '../Department'
import { PostId } from '../Post'
import { EmploymentStatusId } from '../EmploymentStatus'

describe('MemberDomain', () => {
  describe('MemberName #isMaxSize', () => {
    test('メンバー名の上限文字数チェックfalse', async () => {
      const memberName = new MemberName('test')
      expect(memberName.isMaxSize()).toEqual(false)
    })
    test('メンバー名の上限文字数チェックtrue', async () => {
      const memberName = new MemberName('testtesttesttesttesttesttesttest')
      expect(memberName.isMaxSize()).toEqual(true)
    })
  })

  describe('MemberBirthday #getAge', () => {
    test('誕生日から年齢を取得', async () => {
      const memberBirthday = new MemberBirthday(new Date('2000/12/10'))
      expect(memberBirthday.getAge()).toEqual(21)
    })
  })

  describe('MemberGender #getName', () => {
    test('GenderIdから性別名を取得', async () => {
      const memberGender = new MemberGender(1)
      expect(memberGender.getName()).toEqual('男性')
    })
  })

  describe('MemberRelationAttribute #update', () => {
    test('更新用のMemberRelationドメインに変換する', async () => {
      const memberId = new MemberId(1)
      const memberRelationAttribute = new MemberRelationAttribute(
        new MemberProfile(
          new MemberName('test'),
          new MemberBirthday(new Date('1900/8/29')),
          new MemberGender(1)
        ),
        new DepartmentId(1),
        new PostId(1),
        new EmploymentStatusId(1)
      )
      const expected = new MemberRelation(
        new Member(
          new MemberId(1),
          new MemberProfile(
            new MemberName('test'),
            new MemberBirthday(new Date('1900/8/29')),
            new MemberGender(1)
          )
        ),
        new DepartmentId(1),
        new PostId(1),
        new EmploymentStatusId(1)
      )
      expect(memberRelationAttribute.update(memberId)).toEqual(expected)
    })
  })
  
  describe('MemberRelation #from', () => {
    test('MemberRelationドメインに変換する', async () => {
      const id = 1
      const name = 'test'
      const birthday = new Date('2000/12/10')
      const gender = 1
      const departmentId = 1
      const postId = 1
      const employmentStatusId = 1

      const expected = new MemberRelation(
        new Member(
          new MemberId(1),
          new MemberProfile(
            new MemberName('test'),
            new MemberBirthday(new Date('2000/12/10')),
            new MemberGender(1)
          )
        ),
        new DepartmentId(1),
        new PostId(1),
        new EmploymentStatusId(1)
      )
      expect(MemberRelation.from(
        id,
        name,
        birthday,
        gender,
        departmentId,
        postId,
        employmentStatusId
      )).toEqual(expected)
    })
  })
})

UseCaseのテスト

次にUseCaseのテストを書いていきます。

MemberPortをモックし、メソッドが呼び出されたら返却されるレスポンスを定義して返してあげるようにします。レスポンスデータはモックできるものはモックし、登録系などバリデーションするものは実値で書いてます。

・MemberUseCase.spec.ts

import { MemberPort } from '../../port/MemberPort'
import { MemberUseCase } from '../MemberUseCase'
import "reflect-metadata"
import { mock } from './helper'
import { when } from 'jest-when'
import { MemberRelation, MemberRelationAttribute, MemberRelations } from '../../domain/MemberRelation'
import { Member, MemberId, MemberProfile } from '../../domain/Member'
import { MemberName } from '../../domain/Member'
import { MemberBirthday } from '../../domain/Member'
import { MemberGender } from '../../domain/Member'
import { DepartmentId } from '../../domain/Department'
import { PostId } from '../../domain/Post'
import { EmploymentStatusId } from '../../domain/EmploymentStatus'
import { PaymentAmount, PaymentDate, PaymentType, Remark, SalaryAttribute } from '../../domain/Salary'

const memberPort = mock<MemberPort>()

describe('MemberUseCase', () => {
  describe('find', () => {
    test('memberIdから1人のメンバーを取得する', async () => {
      const memberId = mock<MemberId>()
      const expected = mock<MemberRelation>()

      const memberFindFn = jest.fn()
      when(memberFindFn).calledWith(memberId).mockReturnValue(expected)
      memberPort.find = memberFindFn

      const target = new MemberUseCase(memberPort)
      const result = await target.find(memberId)

      expect(memberFindFn).toHaveBeenCalledTimes(1)
      expect(result).toEqual(expected)
    })
  })

  describe('findAll', () => {
    test('全てのメンバーを取得する', async () => {
      const expected = mock<MemberRelations>()

      const memberFindAllFn = jest.fn()
      when(memberFindAllFn).mockReturnValue(expected)
      memberPort.findAll = memberFindAllFn

      const target = new MemberUseCase(memberPort)
      const result = await target.findAll()

      expect(memberFindAllFn).toHaveBeenCalledTimes(1)
      expect(result).toEqual(expected)
    })
  })

  describe('create', () => {
    test('メンバーを新規登録する', async () => {
      const member = new MemberRelationAttribute(
        new MemberProfile(
          new MemberName('test'),
          new MemberBirthday(new Date()),
          new MemberGender(1)
        ),
        new DepartmentId(1),
        new PostId(1),
        new EmploymentStatusId(1)
      )

      const memberCreateFn = jest.fn()
      memberPort.create = memberCreateFn

      const target = new MemberUseCase(memberPort)

      await target.create(member)

      expect(memberCreateFn).toHaveBeenCalledTimes(1)
    })
  })

  describe('createSalary', () => {
    test('メンバーの給与情報を登録する', async () => {
      const memberId = mock<MemberId>()
      const salary = new SalaryAttribute(
        new PaymentAmount(10000),
        new PaymentType('bonus'),
        new Remark('test'),
        new PaymentDate(new Date())
      )

      const memberCreateSalaryFn = jest.fn()
      memberPort.createSalary = memberCreateSalaryFn

      const target = new MemberUseCase(memberPort)
      await target.createSalary(salary, memberId)

      expect(memberCreateSalaryFn).toHaveBeenCalledTimes(1)
    })
  })

  describe('update', () => {
    test('メンバーを更新する', async () => {
      const memberId = mock<MemberId>()
      const targetMember = new MemberRelation(
        new Member(
          new MemberId(1),
          new MemberProfile(
            new MemberName('test'),
            new MemberBirthday(new Date()),
            new MemberGender(1)
          )
        ),
        new DepartmentId(1),
        new PostId(1),
        new EmploymentStatusId(1)
      )

      const updateMember = new MemberRelation(
        new Member(
          new MemberId(1),
          new MemberProfile(
            new MemberName('test'),
            new MemberBirthday(new Date()),
            new MemberGender(1)
          )
        ),
        new DepartmentId(1),
        new PostId(1),
        new EmploymentStatusId(1)
      )

      const memberRelationAttribute = new MemberRelationAttribute(
        new MemberProfile(
          new MemberName('test'),
          new MemberBirthday(new Date()),
          new MemberGender(1)
        ),
        new DepartmentId(1),
        new PostId(1),
        new EmploymentStatusId(1)
      )

      const memberUpdateFn = jest.fn()
      memberPort.update = memberUpdateFn

      const memberRelationAttributeUpdateFn = jest.spyOn(memberRelationAttribute, "update")

      when(memberPort.find).calledWith(memberId).mockResolvedValue(targetMember)
      when(memberRelationAttributeUpdateFn).calledWith(targetMember.member.id).mockReturnValue(updateMember)
      when(memberPort.update).calledWith(updateMember)

      const target = new MemberUseCase(memberPort)
      
      await target.update(memberId, memberRelationAttribute)

      expect(memberUpdateFn).toHaveBeenCalledTimes(1)
    })
  })

  describe('delete', () => {
    test('メンバーを削除する', async () => {
      const memberId = mock<MemberId>()
      const memberDeleteFn = jest.fn()
      memberPort.delete = memberDeleteFn

      const target = new MemberUseCase(memberPort)
      await target.delete(memberId)

      expect(memberDeleteFn).toHaveBeenCalledTimes(1)
    })
  })
})

Gateway・Controllerのテスト

Gateway・Controllerのテストを書いていきます。これらのレイヤら主に変換処理を行うためテストが長くなりがちです。

やっていることはシンプルでGatewayだったらUseCaseから受け取ったドメインをDriver用にプリミティブなオブジェクトに変換して渡してあげ、Driverから受け取ったレスポンスデータをドメインに詰め直す処理をしています。テストとしてはそれらがちゃんと期待しているデータに変換され期待しているメソッドが呼び出されているかをアサートしています。

privateなメソッドに関してはtarget[“hoge”](fuga)のようにアクセスしてテストを行っています。

・MemberGateway.spec.ts

import { mock } from './helper'
import { when } from 'jest-when'
import { MemberDriver, MemberEntity } from '../../driver/MemberDriver'
import { MemberGateway } from '../MemberGateway'
import { Member, MemberBirthday, MemberGender, MemberId, MemberName, MemberProfile } from '../../domain/Member'
import { MemberRelation, MemberRelationAttribute, MemberRelations } from '../../domain/MemberRelation'
import { DepartmentId } from '../../domain/Department'
import { PostId } from '../../domain/Post'
import { EmploymentStatusId } from '../../domain/EmploymentStatus'
import { PaymentAmount, PaymentDate, PaymentType, Remark, SalaryAttribute } from '../../domain/Salary'
const memberDriver = mock<MemberDriver>()

describe('MemberGateway', () => {
  describe('find', () => {
    test('memberIdから1人のメンバーをDriverから取得してDomainに変換する', async () => {
      const memberId = new MemberId(1)
      const memberEntity: MemberEntity = {
        member: {
          id: 1,
          name: 'test',
          birthday: new Date("1900/8/29"),
          gender: 1
        },
        departmentId: 1,
        postId: 1,
        employmentStatusId: 1
      }
      const expected = new MemberRelation(
        new Member(
          new MemberId(1),
          new MemberProfile(
            new MemberName('test'),
            new MemberBirthday(new Date("1900/8/29")),
            new MemberGender(1)
          )
        ),
        new DepartmentId(1),
        new PostId(1),
        new EmploymentStatusId(1)
      )

      const target = new MemberGateway(memberDriver)

      const memberFindFn = jest.fn()
      memberDriver.find = memberFindFn
      const convertMemberValueFn = jest.fn()
      target['convertMemberValue'] = convertMemberValueFn

      when(memberFindFn).calledWith(1).mockResolvedValue(memberEntity)
      when(convertMemberValueFn).calledWith(memberEntity).mockResolvedValue(expected)

      const result = await target.find(memberId)

      expect(memberFindFn).toHaveBeenCalledTimes(1)
      expect(convertMemberValueFn).toHaveBeenCalledTimes(1)
      expect(result).toEqual(expected)
    })
  })

  describe('findAll', () => {
    test('Driverから全てのメンバーを取得しDomainに変換する', async () => {
      const memberEntity: MemberEntity[] = [
        {
          member: {
            id: 1,
            name: 'test1',
            birthday: new Date("1900/8/29"),
            gender: 1
          },
          departmentId: 1,
          postId: 1,
          employmentStatusId: 1
        },
        {
          member: {
            id: 2,
            name: 'test2',
            birthday: new Date("1900/8/29"),
            gender: 2
          },
          departmentId: 2,
          postId: 2,
          employmentStatusId: 2
        }
      ]
      const expected = new MemberRelations(
        [
          new MemberRelation(
            new Member(
              new MemberId(1),
              new MemberProfile(
                new MemberName('test1'),
                new MemberBirthday(new Date("1900/8/29")),
                new MemberGender(1)
              )
            ),
            new DepartmentId(1),
            new PostId(1),
            new EmploymentStatusId(1)
          ),
          new MemberRelation(
            new Member(
              new MemberId(2),
              new MemberProfile(
                new MemberName('test2'),
                new MemberBirthday(new Date("1900/8/29")),
                new MemberGender(2)
              )
            ),
            new DepartmentId(2),
            new PostId(2),
            new EmploymentStatusId(2)
          )
        ]
      )

      const target = new MemberGateway(memberDriver)

      const memberFindAllFn = jest.fn()
      memberDriver.findAll = memberFindAllFn
      when(memberFindAllFn).calledWith().mockResolvedValue(memberEntity)

      const result = await target.findAll()

      expect(memberFindAllFn).toHaveBeenCalledTimes(1)
      expect(result).toEqual(expected)
    })
  })

  describe('create', () => {
    test('メンバーを登録する', async () => {
      const member = new MemberRelationAttribute(
        new MemberProfile(
          new MemberName('test'),
          new MemberBirthday(new Date("1900/8/29")),
          new MemberGender(1)
        ),
        new DepartmentId(1),
        new PostId(1),
        new EmploymentStatusId(1)
      )
      const target = new MemberGateway(memberDriver)

      const memberCreateFn = jest.fn()
      memberDriver.create = memberCreateFn

      await target.create(member)

      expect(memberCreateFn).toHaveBeenCalledTimes(1)
    })
  })

  describe('createSalary', () => {
    test('メンバーの給与情報を登録する', async () => {
      const memberId = new MemberId(1)
      const salary = new SalaryAttribute(
        new PaymentAmount(10000),
        new PaymentType('bonus'),
        new Remark('test'),
        new PaymentDate(new Date())
      )
      const target = new MemberGateway(memberDriver)

      const memberCreateSalaryFn = jest.fn()
      memberDriver.createSalary = memberCreateSalaryFn

      await target.createSalary(salary, memberId)

      expect(memberCreateSalaryFn).toHaveBeenCalledTimes(1)
    })
  })

  describe('update', () => {
    test('メンバーを更新する', async () => {
      const member = new MemberRelation(
        new Member(
          new MemberId(1),
          new MemberProfile(
            new MemberName('test1'),
            new MemberBirthday(new Date("1900/8/29")),
            new MemberGender(1)
          )
        ),
        new DepartmentId(1),
        new PostId(1),
        new EmploymentStatusId(1)
      )
      const target = new MemberGateway(memberDriver)

      const memberUpdateFn = jest.fn()
      memberDriver.update = memberUpdateFn

      await target.update(member)

      expect(memberUpdateFn).toHaveBeenCalledTimes(1)
    })
  })

  describe('delete', () => {
    test('メンバーを削除する', async () => {
      const memberId = new MemberId(1)
      const target = new MemberGateway(memberDriver)

      const memberDeleteFn = jest.fn()
      memberDriver.delete = memberDeleteFn

      await target.delete(memberId)

      expect(memberDeleteFn).toHaveBeenCalledTimes(1)
    })
  })

  describe('convertMemberValue', () => {
    test('MemberValueドメインに変換する', async () => {
      const member: MemberEntity = {
        member: {
          id: 1,
          name: 'test',
          birthday: new Date("1900/8/29"),
          gender: 1
        },
        departmentId: 1,
        postId: 1,
        employmentStatusId: 1
      }

      const expected = new MemberRelation(
        new Member(
          new MemberId(1),
          new MemberProfile(
            new MemberName('test'),
            new MemberBirthday(new Date("1900/8/29")),
            new MemberGender(1)
          )
        ),
        new DepartmentId(1),
        new PostId(1),
        new EmploymentStatusId(1)
      )
      
      const target = new MemberGateway(memberDriver)
      const result = await target["convertMemberValue"](member)

      expect(result).toEqual(expected)
    })
  })
})

・MemberController.spec.ts

import { mock } from './helper'
import { when } from 'jest-when'
import { Member, MemberBirthday, MemberGender, MemberId, MemberName, MemberProfile } from '../../domain/Member'
import { MemberRelation, MemberRelationAttribute, MemberRelations } from '../../domain/MemberRelation'
import { DepartmentId } from '../../domain/Department'
import { PostId } from '../../domain/Post'
import { EmploymentStatusId } from '../../domain/EmploymentStatus'
import { MemberUseCase } from '../../usecases/MemberUseCase'
import { CreateMemberParams, CreateMemberSalaryParams, MemberController, UpdateMemberParams } from '../MemberController'
import { SalaryUseCase } from '../../usecases/SalaryUseCase'
import { MemberSalary } from '../../domain/MemberSalary'
import { PaymentAmount, PaymentDate, PaymentType, Remark, Salaries, Salary, SalaryAttribute, SalaryId } from '../../domain/Salary'
const memberUseCase = mock<MemberUseCase>()
const salaryUseCase = mock<SalaryUseCase>()

describe('MemberController', () => {
  describe('findMember', () => {
    test('memberIdから1人のメンバーを取得する', async () => {
      const id = 1
      const memberId = new MemberId(id)
      const memberRelation = new MemberRelation(
        new Member(
          new MemberId(1),
          new MemberProfile(
            new MemberName('test1'),
            new MemberBirthday(new Date('1900/8/29')),
            new MemberGender(1)
          )
        ),
        new DepartmentId(1),
        new PostId(1),
        new EmploymentStatusId(1)
      )
      const expected = {
        id: 1,
        name: 'test1',
        birthday: new Date('1900/8/29'),
        age: 121,
        gender: '男性',
        department_id: 1,
        post_id: 1,
        employment_status_id: 1
      }


      const memberFindFn = jest.fn()
      memberUseCase.find = memberFindFn

      const target = new MemberController(memberUseCase, salaryUseCase)
      const serializeMemberForDetailFn = jest.fn()
      target['serializeMemberForDetail'] = serializeMemberForDetailFn

      when(memberFindFn).calledWith(memberId).mockResolvedValue(memberRelation)
      when(serializeMemberForDetailFn).calledWith(memberRelation).mockResolvedValue(expected)

      const result = await target.findMember(id)

      expect(memberFindFn).toHaveBeenCalledTimes(1)
      expect(serializeMemberForDetailFn).toHaveBeenCalledTimes(1)
      expect(result).toEqual(expected)
    })
  })

  describe('findMemberSalaries', () => {
    test('memberIdから1人のメンバーの給与情報を取得する', async () => {
      const id = 1
      const memberId = new MemberId(id)
      const memberSalary = new MemberSalary(
        new Member(
          new MemberId(1),
          new MemberProfile(
            new MemberName('test'),
            new MemberBirthday(new Date()),
            new MemberGender(1)
          )
        ),
        new Salaries(
          [
            new Salary(
              new SalaryId(1),
              new SalaryAttribute(
                new PaymentAmount(10000),
                new PaymentType('salary'),
                new Remark('remark1'),
                new PaymentDate(new Date('2001/2/29'))
              )
            ),
            new Salary(
              new SalaryId(2),
              new SalaryAttribute(
                new PaymentAmount(20000),
                new PaymentType('bonus'),
                new Remark('remark2'),
                new PaymentDate(new Date('2001/2/29'))
              )
            )
          ] 
        )
      )

      const expected = {
        member_id: 1,
        member_name: 'test',
        salaries: 
          [
            {
              id: 1,
              payment_amount: 10000,
              payment_type: 'salary',
              remark: 'remark1',
              payment_date: new Date('2001/2/29'),
            },
            {
              id: 2,
              payment_amount: 20000,
              payment_type: 'bonus',
              remark: 'remark2',
              payment_date: new Date('2001/2/29'),
            }
          ]
      }

      const target = new MemberController(memberUseCase, salaryUseCase)
      const memberFindMemberSalariesFn = jest.fn()
      salaryUseCase.findByMemberId = memberFindMemberSalariesFn

      const serializeMemberSalariesFn = jest.fn()
      target['serializeMemberSalaries'] = serializeMemberSalariesFn

      when(memberFindMemberSalariesFn).calledWith(memberId).mockResolvedValue(memberSalary)
      when(serializeMemberSalariesFn).calledWith(memberSalary).mockResolvedValue(expected)

      const result = await target.findMemberSalaries(id)

      expect(memberFindMemberSalariesFn).toHaveBeenCalledTimes(1)
      expect(serializeMemberSalariesFn).toHaveBeenCalledTimes(1)
      expect(result).toEqual(expected)
    })
  })

  describe('findAllMembers', () => {
    test('メンバー全員を取得する', async () => {
      const memberRelations = new MemberRelations(
        [
          new MemberRelation(
            new Member(
              new MemberId(1),
              new MemberProfile(
                new MemberName('test1'),
                new MemberBirthday(new Date('1900/8/29')),
                new MemberGender(1)
              )
            ),
            new DepartmentId(1),
            new PostId(1),
            new EmploymentStatusId(1)
          ),
          new MemberRelation(
            new Member(
              new MemberId(2),
              new MemberProfile(
                new MemberName('test2'),
                new MemberBirthday(new Date('1900/8/29')),
                new MemberGender(1)
              )
            ),
            new DepartmentId(2),
            new PostId(2),
            new EmploymentStatusId(2)
          )
        ]
      )
      const expected = [
        {
          name: 'test1',
          department_id: 1,
          post_id: 1,
          employment_status_id: 1
        },
        {
          name: 'test2',
          department_id: 2,
          post_id: 2,
          employment_status_id: 2
        }
      ]

      const target = new MemberController(memberUseCase, salaryUseCase)

      const memberFindAllMembersFn = jest.fn()
      memberUseCase.findAll = memberFindAllMembersFn
      const serializeMemberForListFn = jest.fn()
      target['serializeMemberForList'] = serializeMemberForListFn

      when(memberFindAllMembersFn).calledWith().mockResolvedValue(memberRelations)
      when(serializeMemberForListFn).calledWith(memberRelations).mockResolvedValue(expected)

      const result = await target.findAllMembers()

      expect(memberFindAllMembersFn).toHaveBeenCalledTimes(1)
      expect(serializeMemberForListFn).toHaveBeenCalledTimes(1)
      expect(result).toEqual(expected)
    })
  })

  describe('createMember', () => {
    test('メンバーを登録する', async () => {
      const createParams = mock<CreateMemberParams>()
      const createMember = mock<MemberRelationAttribute>()

      const memberCreateFn = jest.fn()
      when(memberCreateFn).calledWith(createMember)
      memberUseCase.create = memberCreateFn

      const target = new MemberController(memberUseCase, salaryUseCase)
      await target.createMember(createParams)

      expect(memberCreateFn).toHaveBeenCalledTimes(1)
    })
  })

  describe('createMemberSalary', () => {
    test('メンバーの給与を更新する', async () => {
      const createSalaryParams = mock<CreateMemberSalaryParams>()
      const createSalary = mock<SalaryAttribute>()
      const memberId = mock<MemberId>()

      const createMemberSalaryFn = jest.fn()
      when(createMemberSalaryFn).calledWith(createSalary, memberId)
      memberUseCase.createSalary = createMemberSalaryFn

      const target = new MemberController(memberUseCase, salaryUseCase)
      await target.createMemberSalary(createSalaryParams)

      expect(createMemberSalaryFn).toHaveBeenCalledTimes(1)
    })
  })

  describe('updateMember', () => {
    test('メンバーを更新する', async () => {
      const id = mock<number>()
      const memberId = mock<MemberId>()

      const deleteMemberFn = jest.fn()
      when(deleteMemberFn).calledWith(memberId)
      memberUseCase.delete = deleteMemberFn

      const target = new MemberController(memberUseCase, salaryUseCase)
      await target.deleteMember(id)

      expect(deleteMemberFn).toHaveBeenCalledTimes(1)
    })
  })

  describe('deleteMember', () => {
    test('メンバーを削除する', async () => {
      const id = mock<number>()
      const updateMemberParams = mock<UpdateMemberParams>()
      const updateMember = mock<MemberRelationAttribute>()
      const memberId = mock<MemberId>()

      const updateMemberFn = jest.fn()
      when(updateMemberFn).calledWith(memberId, updateMember)
      memberUseCase.update = updateMemberFn

      const target = new MemberController(memberUseCase, salaryUseCase)
      await target.updateMember(id, updateMemberParams)

      expect(updateMemberFn).toHaveBeenCalledTimes(1)
    })
  })

  describe('serializeMemberForList', () => {
    test('メンバー一覧用にドメインをオブジェクトに変換する', async () => {
      const members = new MemberRelations(
        [
          new MemberRelation(
            new Member(
              new MemberId(1),
              new MemberProfile(
                new MemberName('test1'),
                new MemberBirthday(new Date('1900/8/29')),
                new MemberGender(1)
              )
            ),
            new DepartmentId(1),
            new PostId(1),
            new EmploymentStatusId(1)
          ),
          new MemberRelation(
            new Member(
              new MemberId(2),
              new MemberProfile(
                new MemberName('test2'),
                new MemberBirthday(new Date('1900/8/29')),
                new MemberGender(2)
              )
            ),
            new DepartmentId(1),
            new PostId(1),
            new EmploymentStatusId(1)
          )
        ]
      )

      const expected = [
        {
          name: 'test1',
          department_id: 1,
          post_id: 1,
          employment_status_id: 1
        },
        {
          name: 'test2',
          department_id: 1,
          post_id: 1,
          employment_status_id: 1
        }
      ]

      const target = new MemberController(memberUseCase, salaryUseCase)
      const result = await target["serializeMemberForList"](members)

      expect(result).toEqual(expected)
    })
  })

  describe('serializeMemberForDetail', () => {
    test('メンバー詳細用にドメインをオブジェクトに変換する', async () => {
      const member = new MemberRelation(
        new Member(
          new MemberId(1),
          new MemberProfile(
            new MemberName('test1'),
            new MemberBirthday(new Date('1900/8/29')),
            new MemberGender(1)
          )
        ),
        new DepartmentId(1),
        new PostId(1),
        new EmploymentStatusId(1)
      )

      const expected = {
        id: 1,
        name: 'test1',
        birthday: new Date('1900/8/29'),
        age: 121,
        gender: '男性',
        department_id: 1,
        post_id: 1,
        employment_status_id: 1
      }

      const target = new MemberController(memberUseCase, salaryUseCase)
      const result = await target["serializeMemberForDetail"](member)

      expect(result).toEqual(expected)
    })
  })

  describe('serializeMemberSalaries', () => {
    test('メンバー給与情報用にドメインをオブジェクトに変換する', async () => {
      const memberSalary = new MemberSalary(
        new Member(
          new MemberId(1),
          new MemberProfile(
            new MemberName('test'),
            new MemberBirthday(new Date()),
            new MemberGender(1)
          )
        ),
        new Salaries(
          [
            new Salary(
              new SalaryId(1),
              new SalaryAttribute(
                new PaymentAmount(10000),
                new PaymentType('salary'),
                new Remark('remark1'),
                new PaymentDate(new Date('2001/2/29'))
              )
            ),
            new Salary(
              new SalaryId(2),
              new SalaryAttribute(
                new PaymentAmount(20000),
                new PaymentType('bonus'),
                new Remark('remark2'),
                new PaymentDate(new Date('2001/2/29'))
              )
            )
          ] 
        )
      )

      const expected = {
        member_id: 1,
        member_name: 'test',
        salaries: [
          {
            id: 1,
            payment_amount: 10000,
            payment_type: 'salary',
            remark: 'remark1',
            payment_date: new Date('2001/2/29')
          },
          {
            id: 2,
            payment_amount: 20000,
            payment_type: 'bonus',
            remark: 'remark2',
            payment_date: new Date('2001/2/29')
          }
        ]
      }

      const target = new MemberController(memberUseCase, salaryUseCase)
      const result = await target["serializeMemberSalaries"](memberSalary)

      expect(result).toEqual(expected)
    })
  })
})

テスト実行

最後にテスト実行していきます。テストが通ると以下のようにpassedにカウントされます。

$ npm run test

PASS src/domain/tests/Member.spec.ts
PASS src/usecases/tests/MemberUseCase.spec.ts
PASS src/controller/tests/MemberController.spec.ts
PASS src/gateway/tests/MemberGateway.spec.ts

Test Suites: 4 passed, 4 total
Tests: 29 passed, 29 total
Snapshots: 0 total
Time: 2.212 s, es

ソフトウェア要件の理解

今回は簡単なメンバー管理システムとして作っていきました。まずソフトウェア要件としてどんなものがあるか挙げていきます。

このように要件を挙げていくことで曖昧な要件から明確な仕様へと発展させていきます。本来なら開発するソフトウェアに詳しい人からヒアリングするのですが、今回は個人開発なので自分で挙げていきました。

• メンバーを管理するシステム
• メンバーは1つの部署に所属し、役職が付いている
• メンバーの基本情報(名前、性別、生年月日など)を入力して登録する
• メンバーの情報は更新や削除ができる
• メンバー一覧や詳細を見ることができる
• 部署一覧と所属しているメンバーの人数を見ることができる
• 役職一覧と役職ごとのメンバーの人数を見ることができる
• メンバーにはそれぞれ雇用形態がある
• 雇用形態一覧と雇用形態ごとのメンバーの人数を見ることができる
• メンバーの給与情報を登録・削除できる
• 給与情報一覧を見ることができる

ユースケース図の作成

ソフトウェア要件を挙げたらユースケース図を作っていきます。このソフトウェアで何ができるのかをユーザー目線で表現します。

今回は管理者のみ使う想定となっており、主にメンバー管理に関するユースケースが想定されます(認証系は省略しています)。

エンティティの抽出

ソフトウェア要件やユースケース図が作成できたら、モデリング(エンティティの抽出)していきます。今回は以下のエンティティ候補が抽出されました。またユビキタス言語として用語を統一させておきます。

その後、モデリングの流れとしてエンティティを識別する属性・振る舞いやバリデーションの検討などがありますが、割愛します。

Typescript + Clean Architecture + DDDでAPIを開発する

本記事ではメンバー関連の一連の処理を中心に取り扱います。Clean Architectureの中心部分から説明していきます。

Enterprise Business Rules

Enterprise Business Rulesではアプリケーション全体の最重要ビジネスルールをカプセル化したドメインを格納しています。

まず先程定義したMemberエンティティをドメインのエンティティとしてどう定義していく考えていきます。

Memberの情報として必要なデータを値オブジェクトとして定義し、それらをまとめたMemberProfileという値オブジェクトを作成します。このMemberProfileにはMember自身の情報のみ持つようにしています。

次にMemberProfileに一意の識別子であるMemberIdをもっとMemberというエンティティを作成しました。

次にMember自身の情報として持っていないが、役職や部署などMemberに関連づけられたデータを持ったMemberRelationというエンティティとMemberの識別子を持っていないMemberRelationAttributeという値オブジェクトを作成しました。

MemberRalationエンティティのstaticなfromメソッドはプリミティブなオブジェクトからエンティティに変換する際に使われます。

Memberに関連する値オブジェクトとエンティティを作成したらそれらの振る舞いとバリデーションを実装していきます。

・Member.ts

import { FCC } from './Fcc'

export class MemberProfile {
  constructor(
    readonly name: MemberName,
    readonly birthday: MemberBirthday,
    readonly gender: MemberGender
  ) {}
}

export class Member {
  constructor(
    readonly id: MemberId,
    readonly member: MemberProfile
  ) {}
}

export class MemberId {
  constructor(readonly value: number) {}
}

export class MemberName {
  constructor(readonly value: string) {}

  isMaxSize() {
    return this.value.length > 30
  }
}

export class MemberBirthday {
  constructor(readonly value: Date) {}

  getAge(): number {
    const nowDate = new Date()
    const birthNumber = 
      this.value.getFullYear() * 10000 
      + (this.value.getMonth() + 1 ) * 100 
      + this.value.getDate();
    const nowNumber =
      nowDate.getFullYear() * 10000 
      + (nowDate.getMonth() + 1 ) * 100 
      + nowDate.getDate();
 
    return Math.floor( (nowNumber - birthNumber) / 10000 );
  }
}

export class MemberGender {
  constructor(readonly value: number) {}

  readonly GENDER = {
    MEN: 1,
    WOMAN: 2
  } as const

  getName(): string {
    return this.value == this.GENDER.MEN ? '男性' : '女性'
  }
}

export class Members extends FCC<Member> {
  constructor(values: Member[]) {
    super(values)
  }
}

・MemberRelation.ts

import { FCC } from "./Fcc"
import { DepartmentId } from "./Department"
import { MemberProfile, MemberId, MemberBirthday, MemberGender, MemberName, Member } from "./Member"
import { PostId } from "./Post"
import { EmploymentStatusId } from "./EmploymentStatus"

export class MemberRelationAttribute {
  constructor(
    readonly memberProfile: MemberProfile,
    readonly departmentId: DepartmentId,
    readonly postId: PostId,
    readonly employmentStatusId: EmploymentStatusId
  ) {}

  update(id: MemberId): MemberRelation {
    return new MemberRelation(
      new Member(
        new MemberId(id.value),
        new MemberProfile(
          new MemberName(this.memberProfile.name.value),
          new MemberBirthday(this.memberProfile.birthday.value),
          new MemberGender(this.memberProfile.gender.value)
        )
      ),
      new DepartmentId(this.departmentId.value),
      new PostId(this.postId.value),
      new EmploymentStatusId(this.employmentStatusId.value)
    )
  }
}

export class MemberRelation {
  constructor(
    readonly member: Member,
    readonly departmentId: DepartmentId,
    readonly postId: PostId,
    readonly employmentStatusId: EmploymentStatusId
  ) {}

  static from(
    id: number,
    name: string,
    birthday: Date,
    gender: number,
    departmentId: number,
    postId: number,
    employmentStatusId: number
  ) {
    return new MemberRelation(
      new Member(
        new MemberId(id),
        new MemberProfile(
          new MemberName(name),
          new MemberBirthday(birthday),
          new MemberGender(gender)
        )
      ),
      new DepartmentId(departmentId),
      new PostId(postId),
      new EmploymentStatusId(employmentStatusId)
    )
  }
}

export class MemberRelations extends FCC<MemberRelation> {
  constructor(values: MemberRelation[]) {
    super(values)
  }
}

Application Business Rules

Application Business Rulesではアプリケーション固有のビジネスルールが含まれ、入出力するデータの流れを調整します。

MemberPortにインターフェイスを定義し、MemberGatewayで具象クラスを実装するようにしています。

MemberUseCaseではMemberControllerから受け取ったドメインをバリデーションなどで精査し、MemberGatewayの具象メソッドを呼び出すようにしています。ちなみにDIライブラリとしてTSyringeを使用しています。

・MemberPort.ts

import { SalaryAttribute } from '../domain/Salary'
import { MemberId } from '../domain/Member'
import { MemberRelation, MemberRelationAttribute, MemberRelations } from '../domain/MemberRelation'

export interface MemberPort {
  findAll(): Promise<MemberRelations>
  find(id: MemberId): Promise<MemberRelation>
  create(member: MemberRelationAttribute): Promise<void>
  createSalary(salary: SalaryAttribute, memberId: MemberId): Promise<void>
  update(member: MemberRelation): Promise<void>
  delete(id: MemberId): Promise<void>
}

・MemberUseCase.ts

import { MemberPort } from '../port/MemberPort'
import { MemberId } from '../domain/Member'
import { MemberRelation, MemberRelationAttribute, MemberRelations } from '../domain/MemberRelation'
import "reflect-metadata"
import { inject, singleton } from "tsyringe"
import { SalaryAttribute } from '../domain/Salary'

@singleton()
export class MemberUseCase {
  constructor(@inject("MemberPort") private memberPort: MemberPort) {}

  find(id: MemberId): Promise<MemberRelation> {
    return this.memberPort.find(id)
  }

  findAll(): Promise<MemberRelations> {
    return this.memberPort.findAll()
  }

  create(member: MemberRelationAttribute): Promise<void> {
    if (member.memberProfile.name.isMaxSize()) {
      throw new Error("名前は30文字以下です")
    }
    return this.memberPort.create(member)
  }

  createSalary(salary: SalaryAttribute, memberId: MemberId): Promise<void> {
    if (salary.remark.isMaxSize()) {
      throw new Error("備考は300文字以下です")
    }

    return this.memberPort.createSalary(salary, memberId)
  }

  async update(id: MemberId, member: MemberRelationAttribute): Promise<void> {
    const targetMember = await this.memberPort.find(id)
    const updateMember = member.update(targetMember.member.id)

    if (updateMember.member.member.name.isMaxSize()) {
      throw new Error("名前は30文字以下です")
    }
    return this.memberPort.update(updateMember)
  }

  delete(id: MemberId): Promise<void> {
    return this.memberPort.delete(id)
  }
}

Interface & Adapter

Interface & Adapterではドメインやユースケースに便利な形式からDBに便利な形式にデータを変換します。

MemberGatewayではMemberUseCaseから渡されたドメインをプリミティブなJson形式のオブジェクトに詰め替えてMemberDriverを呼び出しています。

なぜならDriver層にはドメインの知識を流出させたくないためであり、あくまでDriverに必要なデータだけをプリミティブな形で渡すようにします。

そしてDriverから返ってきた値をドメインに詰め替えてからUseCaseに返すようにします。

MemberControllerではリクエストされたパラメーターをドメインに詰め替えてUseCaseに渡し、UseCaseから返ってきたドメインをレスポンスとして返したい形式に変換して返します。またレスポンスとして返す時もリスポンスの型を定義し、変換して返すようにしています。

このようにこのレイヤでは主に入出力用に変換する処理を行っています。

・MemberGateway.ts

import { MemberPort } from '../port/MemberPort'
import { MemberDriver, MemberEntity } from '../driver/MemberDriver'
import { MemberRelation, MemberRelationAttribute, MemberRelations } from '../domain/MemberRelation'
import { MemberId, MemberGender, MemberName, MemberBirthday, MemberProfile, Member } from '../domain/Member'
import { DepartmentId } from '../domain/Department'
import { PostId } from '../domain/Post'
import { inject, singleton } from "tsyringe"
import { EmploymentStatusId } from '../domain/EmploymentStatus'
import { SalaryAttribute } from '../domain/Salary'

@singleton()
export class MemberGateway implements MemberPort {
  constructor(@inject("MemberDriver") private memberDriver: MemberDriver) {}

  async find(id: MemberId): Promise<MemberRelation> {
    const member: MemberEntity = await this.memberDriver.find(id.value)

    return this.convertMemberValue(member)
  }

  async findAll(): Promise<MemberRelations> {
    const members: MemberEntity[] = await this.memberDriver.findAll()

    return new MemberRelations(
      members.map((member: MemberEntity) => this.convertMemberValue(member))
    )
  }

  async create(member: MemberRelationAttribute): Promise<void> {
    await this.memberDriver.create({
      name: member.memberProfile.name.value,
      birthday: member.memberProfile.birthday.value,
      gender: member.memberProfile.gender.value,
      departmentId: member.departmentId.value,
      postId: member.postId.value,
      employmentStatusId: member.employmentStatusId.value
    })
  }

  async createSalary(salary: SalaryAttribute, memberId: MemberId): Promise<void> {
    await this.memberDriver.createSalary({
      paymentAmount: salary.paymentAmount.value,
      paymentType: salary.paymentType.value,
      remark: salary.remark.value,
      paymentDate: salary.paymentDate.value
    }, memberId.value)
  }

  async update(member: MemberRelation): Promise<void> {
    await this.memberDriver.update({
      id: member.member.id.value,
      name: member.member.member.name.value,
      birthday: member.member.member.birthday.value,
      gender: member.member.member.gender.value,
      departmentId: member.departmentId.value,
      postId: member.postId.value,
      employmentStatusId: member.employmentStatusId.value
    })
  }

  async delete(id: MemberId): Promise<void> {
    await this.memberDriver.delete(id.value)
  }

  private convertMemberValue(member: MemberEntity) {
    const converMember = MemberRelation.from(
      member.member.id,
      member.member.name,
      member.member.birthday,
      member.member.gender,
      member.departmentId,
      member.postId,
      member.employmentStatusId
    )

    return converMember
  }

}

・MemberController.ts

import { MemberUseCase } from '../usecases/MemberUseCase'
import { SalaryUseCase } from '../usecases/SalaryUseCase'
import { MemberRelation, MemberRelationAttribute, MemberRelations } from '../domain/MemberRelation'
import { MemberBirthday, MemberGender, MemberId, MemberName, MemberProfile } from '../domain/Member'
import { DepartmentId } from '../domain/Department'
import { PostId } from '../domain/Post'
import { inject, singleton } from "tsyringe"
import { EmploymentStatusId } from '../domain/EmploymentStatus'
import { MemberSalary } from '../domain/MemberSalary'
import { PaymentAmount, PaymentDate, PaymentType, Remark, SalaryAttribute } from '../domain/Salary'

@singleton()
export class MemberController {
  constructor(
    @inject("MemberUseCase") private memberUseCase: MemberUseCase,
    @inject("SalaryUseCase") private salaryUseCase: SalaryUseCase
  ) {}

  async findMember(id: number): Promise<MemberForDetailResponse> {
    const memberId = new MemberId(id)
    const member: MemberRelation = await this.memberUseCase.find(memberId)
    
    return this.serializeMemberForDetail(member)
  }

  async findMemberSalaries(id: number): Promise<MemberSalaries> {
    const memberId = new MemberId(id)
    const memberSalary: MemberSalary = await this.salaryUseCase.findByMemberId(memberId)

    return this.serializeMemberSalaries(memberSalary)
  }

  async findAllMembers(): Promise<MemberForListResponse[]> {
    const members: MemberRelations = await this.memberUseCase.findAll()

    return this.serializeMemberForList(members)
  }

  async createMember(createParams: CreateMemberParams): Promise<void> {
    const { name, birthday, gender, department_id, post_id, employment_status_id } = createParams
    const createMember = new MemberRelationAttribute(
      new MemberProfile(
        new MemberName(name),
        new MemberBirthday(birthday),
        new MemberGender(gender)
      ),
      new DepartmentId(department_id),
      new PostId(post_id),
      new EmploymentStatusId(employment_status_id)
    )
    await this.memberUseCase.create(createMember)
  }

  async createMemberSalary(createSalaryParams: CreateMemberSalaryParams): Promise<void> {
    const { member_id, payment_amount, payment_type, remark, payment_date } = createSalaryParams
    const createSalary = 
      new SalaryAttribute(
        new PaymentAmount(payment_amount),
        new PaymentType(payment_type),
        new Remark(remark),
        new PaymentDate(payment_date)
      )
    const memberId = new MemberId(member_id)
    await this.memberUseCase.createSalary(createSalary, memberId)
  }

  async updateMember(id: number, updateMemberParams: UpdateMemberParams): Promise<void> {
    const memberId = new MemberId(id)
    const { name, birthday, gender, department_id, post_id, employment_status_id } = updateMemberParams
    const updateMember = new MemberRelationAttribute(
      new MemberProfile(
        new MemberName(name),
        new MemberBirthday(birthday),
        new MemberGender(gender)
      ),
      new DepartmentId(department_id),
      new PostId(post_id),
      new EmploymentStatusId(employment_status_id)
    )
    await this.memberUseCase.update(memberId, updateMember)
  }

  async deleteMember(id: number): Promise<void> {
    const memberId = new MemberId(id)
    await this.memberUseCase.delete(memberId)
  }

  private serializeMemberForList(members: MemberRelations) {
    return members.map((member: MemberRelation) => {
      return {
        name: member.member.member.name.value,
        department_id: member.departmentId.value,
        post_id: member.postId.value,
        employment_status_id: member.employmentStatusId.value
      }
    })
  }

  private serializeMemberForDetail(member: MemberRelation) {
    return {
      id: member.member.id.value,
      name: member.member.member.name.value,
      birthday: member.member.member.birthday.value,
      age: member.member.member.birthday.getAge(),
      gender: member.member.member.gender.getName(),
      department_id: member.departmentId.value,
      post_id: member.postId.value,
      employment_status_id: member.employmentStatusId.value
    }
  }

  private serializeMemberSalaries(memberSalary: MemberSalary) {
    return {
      member_id: memberSalary.member.id.value,
      member_name: memberSalary.member.member.name.value,
      salaries: memberSalary.salaries.map(salary => {
        return {
          id: salary.id.value,
          payment_amount: salary.salaryAttribute.paymentAmount.value,
          payment_type: salary.salaryAttribute.paymentType.value,
          remark: salary.salaryAttribute.remark.value,
          payment_date: salary.salaryAttribute.paymentDate.value,
        }
      })
    }
  }
}

export interface CreateMemberParams {
  name: string,
  birthday: Date,
  gender: number,
  department_id: number,
  post_id: number,
  employment_status_id: number,
}

export interface CreateMemberSalaryParams {
  member_id: number,
  payment_amount: number,
  payment_type: string,
  remark: string,
  payment_date: Date
}

export interface UpdateMemberParams {
  name: string,
  birthday: Date,
  gender: number,
  department_id: number,
  post_id: number,
  employment_status_id: number,
}

export interface MemberForDetailResponse {
  id: number,
  name: string,
  birthday: Date,
  age: number,
  gender: string,
  department_id: number,
  post_id: number,
  employment_status_id: number
}

export interface MemberForListResponse {
  name: string,
  department_id: number,
  post_id: number,
  employment_status_id: number
}

export interface MemberSalaries {
  member_id: number,
  member_name: string,
  salaries: 
    {
      id: number,
      payment_amount: number,
      payment_type: string,
      remark: string,
      payment_date: Date,
    }[]
}

Framework & Driver

Framework & Driverはフレームワークやツールで構成されています。

このレイヤにあるMemberDriverはDBから欲しいデータを取得しMemberGatewayに返すようにしています。今回はDBから取得(ORMはSequelizeを使用)していますが、APIならここでAPIリクエストをして返ってきたデータを返します。返すデータはEntityとして詰め直してGatewayに返します。

MemberGatewayでドメインからJson形式に変換したJsonオブジェクトの型とMemberGatewayに返すEntityの型をここで定義しています。

他にもRouterなどありますがここでは割愛しています。

・MemberDriver.ts

import { singleton } from "tsyringe"
const db = require('../../models')

@singleton()
export class MemberDriver {
  async find(id: number): Promise<MemberEntity> {
    const member = await db.member.findByPk(id, {
      include: [
        { 
          model: db.department,
          as: 'department'
        },
        { 
          model: db.post,
          as: 'post'
        }
      ]
    })
 
    return {
      member: {
        id: member.id,
        name: member.name,
        birthday: member.birthday,
        gender: member.gender,
      },
      departmentId: member.department_id,
      postId: member.post_id,
      employmentStatusId: member.employment_status_id
    }
  }

  async findAll(): Promise<MemberEntity[]> {
    const members = await db.member.findAll({
      include: [
        { 
          model: db.department,
          as: 'department'
        },
        { 
          model: db.post,
          as: 'post'
        }
      ]
    })

    return　members.map((member: MemberModelEntity) => {
      return {
        member: {
          id: member.id,
          name: member.name,
          birthday: member.birthday,
          gender: member.gender,
        },
        departmentId: member.department_id,
        postId: member.post_id,
        employmentStatusId: member.employment_status_id
      }
    }) 
  }

  async create(member: MemberValueProfileJson): Promise<void> {
    await db.member.create({
      name: member.name,
      birthday: member.birthday,
      gender: member.gender,
      department_id: member.departmentId,
      post_id: member.postId,
      employment_status_id: member.employmentStatusId
    })
  }

  async createSalary(salary: SalaryJson, memberId: number): Promise<void> {
    await db.salary.create({
      member_id: memberId,
      payment_amount: salary.paymentAmount,
      payment_type: salary.paymentType,
      remark: salary.remark,
      payment_date: salary.paymentDate,
    })
  }

  async update(memberJson: MemberJson): Promise<void> {
    const targetMember = await db.member.findByPk(memberJson.id)
    targetMember.name = memberJson.name
    targetMember.birthday = memberJson.birthday
    targetMember.gender = memberJson.gender
    targetMember.department_id = memberJson.departmentId
    targetMember.post_id = memberJson.postId
    targetMember.employment_status_id = memberJson.employmentStatusId

    await targetMember.save()
  }

  async delete(id: number): Promise<void> {
    const targetMember = await db.member.findByPk(id)
    await targetMember.destroy()
  }
}

export interface MemberJson {
    id: number,
    name: string,
    birthday: Date,
    gender: number,
    departmentId: number,
    postId: number,
    employmentStatusId: number
}

export interface MemberValueProfileJson {
  name: string,
  birthday: Date,
  gender: number,
  departmentId: number,
  postId: number,
  employmentStatusId: number
}

export interface SalaryJson {
  paymentAmount: number,
  paymentType: string,
  remark: string | null,
  paymentDate: Date
}

export interface MemberEntity {
  member: {
    id: number,
    name: string,
    birthday: Date,
    gender: number
  },
  departmentId: number,
  postId: number,
  employmentStatusId: number
}

export interface MemberModelEntity {
  id: number,
  name: string,
  birthday: Date,
  gender: number,
  department_id: number,
  post_id: number,
  employment_status_id: number
}

DDDとは

「顧客と開発者が業務を戦略的に理解し、共通の言葉を使いながらシステムを発展させる手法」です。

具体的には、チームの共通言語である「ユビキタス言語」を用いて「ドメインモデル」を構築し、それをコードとして実装します。また大規模で密結合なシステムにならないように、「ドメイン」と「境界づけられたコンテキスト」でシステムを分割し、「コアドメイン」という最重要領域に集中して開発を行います。

DDDは高品質のソフトウェアを設計する手法

ここでいう高品質とはバグがないということではなく、ビジネス的に成功していることを指しています。

「事業を理解し、チームの知識を1つにまとめる」ことを重視し、それを「ユビキタス言語」と呼ばれるチームの共通語でプログラムを実装します。

DDDの3原則

1. コアドメインに集中すること
2. ドメインの実践者とソフトウェアの実践者による創造的な共同作業を通じて、モデルを探究すること
3. 明示的な境界づけられたコンテキストの内部で、ユビキタス言語を語ること

DDDで重要なことはビジネス的に成功しているソフトウェアを構築すること

DDDの用語など

モデル

抽象化によって不要な詳細を省いたもの

ドメインモデル

複雑な業務ドメインの中から、システムに必要な概念を適切に抽出したもの

ドメイン

チームが取り組んでいる事業全体

コアドメイン

事業的に最も重要で戦略的に不可欠な部分

サブドメイン

コアドメインではな補助的な部分

境界づけられコンテキスト

ドメインの課題を解決する部分

エンティティと値オブジェクト

エンティティ

• 一意なものを表現する概念
• 一意であるため長期にわたって変化できるオブジェクト
• 一意に識別して変更を管理する必要がないものは値オブジェクト

値オブジェクト

• 一意に識別する必要がないオブジェクト
• 従来はシンプルな文字列型や数値型で実装してしまうような情報を「値オブジェクト」として実装することで、業務をコードとして明確に表現できるようになる
  → primitive型と対比すると値自体に振る舞いを持たせることで凝集度を上げることができる

モデリングとエンティティ(エンティティ発見の流れ)

① ソフトウェア要件の理解

設計を始めるにあたり、まず業務内容から整理していきます。開発する対象業務についてドメインエキスパートから要望を聞き出していきます。

ここでは業務仕様を簡単なソフトウェア用件という形でユースケースやユーザーストーリという形で作成します。

② モデリングを検討しエンティティを抽出

チームで共通のユビキタス言語を構築することを意識して、ドメインエキスパートと議論を行います。

エンティティの抽出においては、シナリオにおいて「変更」というキーワードがある箇所に注目します。主語の用語がエンティティとなる可能性が高くなります。

③ エンティティを識別する属性と振る舞いを検討

エンティティに注目してモデリングを行います。エンティティ設計の初期段階ではエンティティを一意に特定する属性と振る舞いにだけ注目します。

④ 「一意な識別子」の設計

エンティティを識別する一意な識別子を検討します。

一意な識別子を決定したら、一意な識別子(IDや主キー値)の生成方法と生成タイミングについて検討します(生成方法と生成タイミングは省略)。

一意な識別子を設定した後は、その識別子の値を変更しないようにします。もし、識別子が設定済みにもかかわらず、変更処理が呼び出された場合はエラーとなるようにしなければいけません。

⑤ エンティティの振る舞い(メソッド)を検討

エンティティが持つ振る舞いについて検討していきます。ソフトウェア要件に登場する同志に注目することで、メソッドの候補を洗い出していきます。

⑥ エンティティの作成方法を検討

これまで検討してきたモデルをコードとして実装していきます。

エンティティは一意である必要があるため、エンティティのコンストラクタには「識別子の生成に必要な情報」や「問い合わせを行うために必要な情報」を引数として渡します。

⑦ エンティティのバリデーションを検討

エンティティでは「属性単位」「オブジェクト全体」「複数オブジェクト時」という3つの粒度に分けてバリデーションを管理します。

属性単位

エンティティの属性／プロパティに値をセットする場合、「空ではないか」「5文字以上か」「30文字以下か」といった妥当性のチェックを行います。

オブジェクト全体

オブジェクト全体のチェックでは、実装クラスに対応した「バリデータ」クラスを作成し、適切なタイミングで呼び出すようにします。

複数オブジェクト時

複数オブジェクトの状態が妥当かチェックするケースでは、必要な数だけバリデータを用意します。

docker-compose.yml、Dockerfileの作成

・docker-compose.yml

version: '3.4'

services:
  db:
    image: mysql
    environment:
      MYSQL_ROOT_PASSWORD: root
      MYSQL_DATABASE: sample_db
    ports:
      - '3306:3306'
    volumes:
      - data_volume:/var/lib/mysql
    command: --default-authentication-plugin=mysql_native_password

  api:
    image: api
    env_file: ./app.env
    build:
      context: .
      dockerfile: ./Dockerfile
    ports:
      - 5000:5000
    volumes:
      - .:/usr/src/app
    depends_on:
      - db

volumes:
  data_volume:

・Dockerfile

FROM node:16

WORKDIR /usr/src/app

COPY package*.json ./

RUN npm install

COPY . .

EXPOSE 5000

CMD sleep 1; npm run dev

docker-compose.ymlではMySQLの「db」とNode.jsの「api」の2つのサービスを定義しています。

「db」サービスの定義

公式からMySQL 8.0のバージョンのイメージを使用します。

environmentでMySQLに接続する際のパスワードと生成するDBを指定します。portsでポートフォワーディングの設定をしており、今回はホスト側のポート3306からコンテナ側のポート3306に繋がります。

volumesで「data_volume」というボリュームをコンテナの/var/lib/mysql/ディレクトリにマウントすることで、コンテナが削除されてもデータが保持されます。

また、MySQL8.0からはログイン認証方式のデフォルトがcaching_sha2_passwordになったことにより、接続時にエラーが発生するため、旧来の認証方法にするためのコマンドを追加しています。

「api」サービスの定義

apiというimageを指定しています。env_fileでapiコンテナからdbコンテナに接続する際の環境変数が定義されているapp.envファイルを読み込むようにしています。

buildでapiを起動するためのビルドを実行します。今回はDockerfileを指定し、そこでNode.jsのアプリケーションをDocker化しています。

参考：https://nodejs.org/ja/docs/guides/nodejs-docker-webapp/

depends_onは起動順を担保しているだけで、稼働順を担保していない

少しハマったのは、docker-compose upでコンテナの作成・起動を成功するが、APIからDBに接続する際にエラーになったことです。

depend_onでDBが起動が終わったタイミングで接続すると思っていたのですが、よくよく調べてみるとdepends_onは起動順を担保しているだけで、稼働順を担保していないことがわかりました。

つまり、DBから起動していたのですが、DBの起動が完了する前にAPIがDBに接続しようとしていたのです。

そのため、確実にDBが起動完了してからAPIが接続するようにするために「CMD sleep 1; npm run dev」で1秒するスリープさせるようにしました。色々調べてみると公式とかですとシェルを使ってみるとかかいてあったのですが、とりあえずこの方法でやっています。

Sequelizeでマイグレーションを実行する

docker-compose upで問題なくコンテナ作成・起動・接続できたらSequelizeを導入していきます。

SequelizeはNode.jsのORMでマイグレーション機能があり、これを使ってマイグレーションしていきます。以下のコマンドでSequelizeとその依存パッケージをインストールと初期化を行います。

$ docker-compose run --rm api npm i mysql2 sequelize sequelize-cli
$ docker-compose run --rm api npx sequelize-cli init

次に以下のコマンドでモデルとマイグレーションファイルを作成します。今回はToDoアプリを想定しており、tasksというテーブルをつくります。

$ docker-compose run --rm app npx sequelize-cli model:generate --name Task --attributes content:string,status:integer

実行するとモデルとマイグレーションファイルが作成されます。マイグレーションファイルを少し修正しておきます。具体的にstatusにデフォルト値を追加したりcreated_atをCURRENT_TIMESTAMP、updated_atをCURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMPにしました。

・xxxxxxxx-create-task.js

'use strict'
module.exports = {
  up: async (queryInterface, Sequelize) => {
    await queryInterface.createTable('tasks', {
      id: {
        allowNull: false,
        autoIncrement: true,
        primaryKey: true,
        type: Sequelize.INTEGER
      },
      content: {
        type: Sequelize.STRING
      },
      status: {
        type: Sequelize.INTEGER,
        defaultValue: 1
      },
      created_at: {
        allowNull: false,
        type: Sequelize.DATE,
        defaultValue: Sequelize.literal('CURRENT_TIMESTAMP')
      },
      updated_at: {
        allowNull: false,
        type: Sequelize.DATE,
        defaultValue: Sequelize.literal('CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP')
      }
    })
  },
  down: async (queryInterface, Sequelize) => {
    await queryInterface.dropTable('tasks')
  }
}

先ほど起動したMySQLのコンテナの接続情報をconfigファイルに設定して、マイグレーションを実行していきます。正常に実行されれば完了です。

$ docker-compose run --rm app npx sequelize-cli db:migrate

あとはseedersフォルダで初期データを投入することができます。シードファイルを作成して投入したいデータをセットし、以下のコマンドを実行することでシードできます。

$ docker-compose run --rm app npx sequelize-cli db:seed:all

クリーンアーキテクチャとは

クリーンアーキテクチャはソフトウェアをレイヤーに分割することで、関心事の分離を実現し、以下の特性を持ったシステムを生み出します。

• フレームワーク非依存：システムをフレームワークの制約で縛るのではなく、フレームワークをツールとして使用する
• テスト可能：ビジネスルールはUIやDB、サーバー、その他の外部要素がなくてもテストできる
• UI非依存：UIはシステムの他の部分を変更することなく、簡単に変更できる
• データベース非依存：ビジネスルールはDBに束縛されていない
• 外部エージェント非依存：ビジネスルールは外界のインターフェイスについて何も知らない

一般的に縁の中央に近づくほどソフトウェアのレベルが上がり、縁の外側は仕組みで内側は方針となっています。

縁の内側は外側について何も知らず、外側で宣言された関数やクラス、変数などは内側にあるコードで触れてはならず、依存性は外から中だけに向かっていきます。

Clean ArchitectureでAPIを実装する

今回はToDoアプリのAPIをClean Architectureで実装しました。

具体的にはTaskテーブルを作成し、そこにToDoのデータが格納され、一覧や詳細、登録などをこのAPIで実現できるようになっています。

中身はシンプルなCRUDで、どの処理をどこに書くかを意識して実装しました。また、ドメイン層ではDDDを意識した作りにしました。といっても今回はドメインがTaskしかないため振る舞いはほどんどなく、簡易的なものになっています。

Enterprise Business Rules(企業のビジネスルール)

このレイヤーにはアプリケーション全体の最重要ビジネスルールをカプセル化したドメインを格納しています。

今回はToDoアプリを想定したAPIとなっており、ビジネスロジックは更新時のみで、データ構造とアクセサメソッドのみ定義しています。

またDDDを意識した実装にし、それぞれのプロパティを値オブジェクトとして定義しています。

コンストラクタの引数が関数内で変更されないため、readonlyプロパティをつけています。こうすることで、引数が読み込み専用で変更されないことが担保されます。

・Domain

import moment from 'moment'
import { FCC } from './Fcc'

export class Task {
  constructor(
    readonly id: TaskId,
    readonly content: TaskContent,
    readonly status: TaskStatus,
    readonly createdAt: TaskCreatedAt,
    readonly updatedAt: TaskUpdatedAt
  ) {}

  readonly STATUS = {
    TODO: 1,
    DONE: 2,
  } as const;

  updateStatus(status: number) {
    const task = new Task(
      new TaskId(this.id.value),
      new TaskContent(this.content.value),
      new TaskStatus(Number(status)),
      new TaskCreatedAt(this.createdAt.value),
      new TaskUpdatedAt(this.updatedAt.value)
    )

    return task
  }
}

export class TaskId {
  constructor(readonly value: number) {}
}

export class TaskContent {
  constructor(readonly value: string) {}
}

export class TaskStatus {
  constructor(readonly value: number) {}
}

export class TaskCreatedAt {
  constructor(readonly value: moment.Moment) {}
}

export class TaskUpdatedAt {
  constructor(readonly value: moment.Moment) {}
}

export class Tasks extends FCC<Task> {
  constructor(values: Task[]) {
    super(values)
  }
}

Application Business Rules(アプリケーションのビジネスルール)

このレイヤーにはアプリケーション固有のビジネスルールが含まれ、入出力するデータの流れを調整します。

このレイヤーの変更がドメインに影響を与えることはなく、またこのレイヤーがDBやUI、共通のフレームワークなどの外部の変更の影響を受けることもありません。

ここでは依存関係を中心に向かうようにしたいため、依存関係逆転の原則(DIP)を使ってPortにインターフェイスを定義しています。そうすることでUseCaseがPortというインターフェイスに依存することになり、Portのインスタンス化をGatewayで行うようにしています。

具体的にはコンストラクタでTaskGatewayをTaskPortとして受け取ることで、インターフェイスを継承しています。

・UseCase

import { TaskPort } from '../port/TaskPort'

export class TaskUseCase {
  private taskPort: TaskPort

  constructor(taskPort: TaskPort) {
    this.taskPort = taskPort
  }

  getById(id: number) {
    return this.taskPort.find(id)
  }

  getList() {
    return this.taskPort.findAll()
  }

  create(content: string) {
    return this.taskPort.create(content)
  }

  async update(id: number, status: number) {
    const task = await this.taskPort.find(id)
    const updateTask = task.updateStatus(status)
    return this.taskPort.update(updateTask)
  }

  async delete(id: number) {
    return this.taskPort.delete(id)
  }
}

・Port

import { Task, Tasks } from '../domain/Task'

export interface TaskPort {
  findAll(): Promise<Tasks>
  find(id: number): Promise<Task>
  create(content: String): Promise<any>
  update(task: Task): Promise<any>
  delete(id: number): Promise<any>
}

Interface Adaptors(インターフェイスアダプター)

このレイヤーではドメインやユースケースに便利な形式から、永続フレームワーク(DB)に便利な形式にデータを変換します。

円の内側のコードは、DBについて何も知らず、DBがSQLであれば全てのSQLはこのレイヤーに限定する必要があります。

ここではPortの具象クラスであるGatewayとResourceを格納しています。そのため、GatewayではPortのインターフェイスを継承しています。

GatewayではconvertTaskメソッドでSQLから返ってきたEntityをDomainに変換する処理をしています。

ResourceのserializeTaskメソッドでTaskドメインからAPIのレスポンスとして返したい形に変換しています。

・Gateway

import { TaskPort } from '../port/TaskPort'
import { TaskDriver } from '../driver/TaskDriver'
import {
  Task,
  TaskContent,
  TaskCreatedAt,
  TaskId,
  Tasks,
  TaskStatus,
  TaskUpdatedAt
} from '../domain/Task'

export class TaskGateway implements TaskPort {
  private taskDriver: TaskDriver

  constructor(taskDriver: TaskDriver) {
    this.taskDriver = taskDriver
  }

  private convertTask(result: any) {
    const task = new Task(
      new TaskId(result.id),
      new TaskContent(result.content),
      new TaskStatus(result.status),
      new TaskCreatedAt(result.created_at),
      new TaskUpdatedAt(result.updated_at)
    )

    return task
  }

  async find(id: number): Promise<Task> {
    const result = await this.taskDriver.find(id)

    return this.convertTask(result[0])
  }

  async findAll(): Promise<Tasks> {
    try {
      const results = await this.taskDriver.findAll()

      return results.map((result: Task) => {
        return this.convertTask(result)
      })
    } catch (e) {
      throw e
    }
  }

  async create(content: String): Promise<any> {
    try {
      const result = await this.taskDriver.create(content)

      return result
    } catch (e) {
      throw e
    }
  }

  async update(task: Task): Promise<any> {
    try {
      const result = await this.taskDriver.update(task)

      return result
    } catch (e) {
      throw e
    }
  }

  async delete(id: number): Promise<any> {
    try {
      const result = await this.taskDriver.delete(id)

      return result
    } catch (e) {
      throw e
    }
  }
}

・Resource

import { TaskUseCase } from '../usecases/TaskUseCase'
import { Task } from '../domain/Task'

export class TaskResource {
  private taskUseCase: TaskUseCase

  constructor(taskUseCase: TaskUseCase) {
    this.taskUseCase = taskUseCase
  }

  async findTask(req: any, res: any) {
    const id = req.params.id
    const result = await this.taskUseCase.getById(id)

    return this.serialize(result)
  }

  async findAllTasks(req: any, res: any) {
    const result = await this.taskUseCase.getList()

    return this.serialize(result)
  }

  async createTask(req: any, res: any) {
    const { content } = req.body
    const result = await this.taskUseCase.create(content)
    return result
  }

  async updateTask(req: any, res: any) {
    const id = req.params.id
    const { status } = req.body
    const result = await this.taskUseCase.update(id, status)
    return result
  }

  async deleteTask(req: any, res: any) {
    const id = req.params.id
    const result = await this.taskUseCase.delete(id)
    return result
  }

  private serializeTask = (task: Task) => {
    return {
      id: task.id.value,
      content: task.content.value,
      status: task.status.value,
      createdAt: task.createdAt.value,
      updatedAt: task.updatedAt.value
    }
  }

  private serialize(data: any) {
    if (!data) {
      throw new Error('data is undefined or null')
    }
    if (Array.isArray(data)) {
      return data.map(task => this.serializeTask(task))
    }
    return this.serializeTask(data)
  }
}

Frameworks & Drivers(フレームワークとドライバ)

最も外側の円は、フレームワークやツールで構成されています。例えばDBやWebフレームワークなどがこのレイヤーに格納されています。RouterやDriverもこのレイヤーに格納しています。

Tasksテーブルのカラムであるcreated_atとupdated_atはdefaultValueを「CURRENT_TIMESTAMP」、「CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP」にして自動的に登録されるようにしています。

statusもdefaultValueを1にすることでcreateではデフォルトで登録できるようにしています。

・Driver

import { Task } from '../domain/Task'
import { IDBConnection } from './db/IDBConnection'

export class TaskDriver {
  private connection: any

  constructor(connection: IDBConnection) {
    this.connection = connection
  }

  async find(id: number): Promise<any> {
    const result = await this.connection.execute(
      'select * from tasks where id = ?',
      id
    )

    return result
  }

  async findAll(): Promise<any> {
    const result = await this.connection.execute('select * from tasks')
    return result
  }

  async create(content: String): Promise<any> {
    const result = await this.connection.execute(
      'insert into tasks (content) values (?)',
      content
    )
    return result
  }

  async update(task: Task): Promise<any> {
    const result = this.connection.execute(
      'update tasks set status = ? where id = ?',
      [task.status.value, task.id.value]
    )
    return result
  }

  async delete(id: number): Promise<any> {
    const result = await this.connection.execute(
      'delete from tasks where id = ?',
      id
    )
    return result
  }
}

Routerではexpressのrouterを使ってルーティング設定をしています。

またRouterで各層の依存関係を定義(DI)することで、それぞれレイヤーで利用可能な状態にします。

・Router

import express = require('express')
import { TaskUseCase } from '../usecases/TaskUseCase'
import { TaskGateway } from '../gateway/TaskGateway'
import { TaskResource } from '../rest/TaskResource'
import { MysqlConnection } from './db/MysqlConnection'
import { TaskDriver } from './TaskDriver'

const mysqlConnection = new MysqlConnection()
const taskDriver = new TaskDriver(mysqlConnection)
const taskGateway = new TaskGateway(taskDriver)
const taskUsecase = new TaskUseCase(taskGateway)
const taskResource = new TaskResource(taskUsecase)

const router = express.Router()

router.get('/tasks', async (req: express.Request, res: express.Response) => {
  const results = await taskResource.findAllTasks(req, res)
  res.send(results)
})

router.get(
  '/tasks/:id',
  async (req: express.Request, res: express.Response) => {
    const result = await taskResource.findTask(req, res)

    res.send(result)
  }
)

router.post('/tasks', async (req: express.Request, res: express.Response) => {
  const result = await taskResource.createTask(req, res)
  res.send(result)
})

router.patch(
  '/tasks/:id',
  async (req: express.Request, res: express.Response) => {
    const result = await taskResource.updateTask(req, res)
    res.send(result)
  }
)

router.delete(
  '/tasks/:id',
  async (req: express.Request, res: express.Response) => {
    const result = await taskResource.deleteTask(req, res)
    res.send(result)
  }
)

export default router

Serverではexpressを使ってサーバー処理を書いています。routerのパスや待ち受けるポート番号などを設定しています。

また、CORSで「http://localhost:3000」のみアクセスできるようにしています。

・Server

import express from 'express'
import router from './router'
import bodyParser from 'body-parser'
import cors from 'cors'

const app = express()

app.use(bodyParser.urlencoded({ extended: false }))
app.use(bodyParser.json())

const allowedOrigins = ['http://localhost:3000']

const options: cors.CorsOptions = {
  origin: allowedOrigins
}
app.use(cors(options))
app.use('/api', router)

app.listen(5000, () => {
  console.log('listening on port 5000')
})

export default app

・IDBConnection

export abstract class IDBConnection {
  abstract execute(query: string, params: any): any
}

・MysqlConnection

import mysql from 'mysql'
import dotenv from 'dotenv'
import util from 'util'
import { IDBConnection } from './IDBConnection'

export class MysqlConnection extends IDBConnection {
  private pool: any

  constructor() {
    super()
    dotenv.config()
    this.pool = mysql.createPool({
      connectionLimit: 5,
      host: process.env.DB_HOST_DEV,
      user: process.env.DB_USER_DEV,
      password: process.env.DB_PASSWORD_DEV,
      database: process.env.DB_NAME_DEV,
      timezone: 'utc'
    })

    this.pool.getConnection((error: any, connection: any) => {
      if (error) {
        if (error.code === 'PROTOCOL_CONNECTION_LOST') {
          console.error('Database connection was closed.')
        }
        if (error.code === 'ER_CON_COUNT_ERROR') {
          console.error('Database has too many connections.')
        }
        if (error.code === 'ECONNREFUSED') {
          console.error('Database connection was refused.')
        }
      }

      if (connection) connection.release()

      return
    })
    this.pool.query = util.promisify(this.pool.query)

    // pool event
    this.pool.on('connection', (connection: any) => {
      console.log('mysql connection create')
    })

    this.pool.on('release', (connection: any) => {
      console.log('Connection %d released', connection.threadId)
    })
  }

  execute(query: string, params: any = null) {
    if (params !== null) {
      return this.pool.query(query, params)
    } else {
      return this.pool.query(query)
    }
  }
}

SOLID原則

SOLID原則は、関数やデータ構造をどのようにクラスに組み込むのか、そしてクラスの相互接続をどのようにするのかといったことを教えてくれます。SOLID原則の目的は以下のような声質を持つ中間レベルのソフトウェア構造を作ることです。

• 変更に強いこと
• 理解しやすいこと
• コンポーネントの基盤として多くのソフトウェアシステムで利用できること

単一責任の原則(SRP: Single Responsibility Principle)

本書では単一責任の原則に違反しているEmployeeクラスの例からその必要性と解決策を提示していました。

給与システムにおけるEmployeeクラスがあり、calculatePay()、reportHours()、save()の3つのメソッドがあります。

それぞれのメソッドは以下の責務を負っています。

• calculatePay()：経理部門が規定する。報告先はCFO
• reportHours()：人事部門が規定して使用する。報告先はCOO
• save()：データベースを管理者が規定する。報告先はCTO

これらのメソッドをひとつのEmployeeクラスに入れると、開発者は全てのアクターを結合することになり、CFOのチームの何らかの操作が、COOチームの使うものに影響を及ぼしてしまうことになります。例えばCFOチームのみが算出方法に手を加える場合が発生した時に、CFOチーム以外の算出方法も変更されてしまい問題が起きます。

解決策

一番わかりやすい解決法として、データを関数から切り離すやり方があります。この場合だと3つのクラスに分けそこからEmployeeDataクラスを使うようにします。EmployeeDataクラスはシンプルなデータ構造のみを保持し、メソッドは含みません。

この方法の弱点として開発者が3つのクラスをインスタンス化して、追跡しなければいけなくなることです。この弱点を解消するのが以下のFacadeパターンです。

EmployeeFacadeクラスは実行したいメソッドを持つクラスのインスタンを生成して処理を委譲するだけのシンプルな構造です。これにより複数をそれぞれインスタンス化して追跡する必要がなくなりなります。

オープン・クローズドの原則(OCP: Open-Closed Principle)

オープン・クローズドの原則は、ソフトウェアの振る舞いは既存の成果物を変更せず拡張できるようにすべきという考え方です。

変更の影響を受けずにシステムを拡張する目的を達成するために、システムをコンポーネントに分割して、コンポーネントの依存関係を階層構造にすることです。そして、上位レベルのコンポーネントが下位レベルのコンポーネントの変更の影響を受けないようにします。

リスコフの置換原則(LSP: Liskov Substitution Principle)

Licenseクラスを例にリスコフの置換原則をみてみます。

LicenseクラスにはcalcFee()メソッドがあり、Billingアプリケーションから呼ばれています。またLicenseの派生型であるPersonalLicenseとBusinessLicenseがあります。これらはそれぞれ異なるアルゴリズムを用いてライセンス料を計算します。

このBillingアプリケーションは2つの派生型に依存していないため、リスコフの置換原則を満たしているといえます。どちらの派生型もLicense型に置き換えることができます。

インターフェイス分類の原則(ISP: Interface Segregation Principle)

インターフェイス分類の原則では必要としないお荷物を抱えたものに依存していると、予期せぬトラブルの元になることがあります。

本書ではシステムSを担当するアーキテクトが、あるフレームワークFをシステムに導入した場合の例として紹介しています。このフレームワークFの作者は、フレームワークを特定のデータベースDのためだけに作っており、SはFに依存しており、さらにFはDに依存していることになります。

FはDの全ての機能を使っているわけはなく、その使っていない部分が変更されてもFは再度不必要なデプロイをすることになります。さらにDの一部の機能に障害が発生すると、それがFやSの障害の原因になってしまう可能性もあります。

依存関係逆転の原則(DIP: Dependency Inversion Principle)

依存関係逆転の原則は、上位レベルの方針の実装コードは下位レベルの詳細の実装コードに依存すべきではなく、逆に詳細側が方針に依存すべきであるという原則です。

ただ依存関係逆転の原則を考える時にはOSやプラットフォーム周りは気にしないことが多いです。変化しないとみなして、こうした具象への依存は許容することにしています。

依存したくないのは、システム内の変化しやすい具象要素です。開発中のモジュールや頻繁に変更され続けているモジュールがその対象になります。

参考：Clean Architecture 達人に学ぶソフトウェアの構造と設計